claude-code-swarm 0.3.3 → 0.3.5

package/references/agent-inbox/test/sqlite-storage.test.ts

@@ -0,0 +1,243 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { SqliteStorage } from "../src/storage/sqlite.js";
+import type { Agent, Message, Conversation, Turn } from "../src/types.js";
+
+function makeAgent(overrides: Partial<Agent> = {}): Agent {
+  return {
+    agent_id: "agent-1",
+    scope: "default",
+    status: "active",
+    metadata: {},
+    registered_at: "2025-01-01T00:00:00Z",
+    last_active_at: "2025-01-01T00:00:00Z",
+    ...overrides,
+  };
+}
+
+function makeMessage(overrides: Partial<Message> = {}): Message {
+  return {
+    id: "msg-1",
+    scope: "default",
+    sender_id: "agent-1",
+    recipients: [{ agent_id: "agent-2", kind: "to" }],
+    content: { type: "text", text: "hello" },
+    importance: "normal",
+    metadata: {},
+    created_at: "2025-01-01T00:00:00Z",
+    ...overrides,
+  };
+}
+
+describe("SqliteStorage", () => {
+  let storage: SqliteStorage;
+
+  beforeEach(() => {
+    storage = new SqliteStorage({ path: ":memory:" });
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  describe("Agents", () => {
+    it("should put and get an agent", () => {
+      const agent = makeAgent();
+      storage.putAgent(agent);
+      const result = storage.getAgent("agent-1");
+      expect(result).toBeDefined();
+      expect(result!.agent_id).toBe("agent-1");
+      expect(result!.status).toBe("active");
+    });
+
+    it("should list agents by scope", () => {
+      storage.putAgent(makeAgent({ agent_id: "a1", scope: "team-a" }));
+      storage.putAgent(makeAgent({ agent_id: "a2", scope: "team-b" }));
+      storage.putAgent(makeAgent({ agent_id: "a3", scope: "team-a" }));
+
+      expect(storage.listAgents("team-a")).toHaveLength(2);
+      expect(storage.listAgents("team-b")).toHaveLength(1);
+      expect(storage.listAgents()).toHaveLength(3);
+    });
+
+    it("should remove an agent", () => {
+      storage.putAgent(makeAgent());
+      expect(storage.removeAgent("agent-1")).toBe(true);
+      expect(storage.getAgent("agent-1")).toBeUndefined();
+    });
+
+    it("should update agent on re-put", () => {
+      storage.putAgent(makeAgent({ status: "active" }));
+      storage.putAgent(makeAgent({ status: "offline" }));
+      expect(storage.getAgent("agent-1")!.status).toBe("offline");
+    });
+  });
+
+  describe("Messages", () => {
+    it("should store and retrieve message with recipients", () => {
+      const msg = makeMessage();
+      storage.putMessage(msg);
+      const result = storage.getMessage("msg-1");
+      expect(result).toBeDefined();
+      expect(result!.sender_id).toBe("agent-1");
+      expect(result!.recipients).toHaveLength(1);
+      expect(result!.recipients[0].agent_id).toBe("agent-2");
+      expect(result!.content).toEqual({ type: "text", text: "hello" });
+    });
+
+    it("should get inbox for agent", () => {
+      storage.putMessage(
+        makeMessage({ id: "m1", recipients: [{ agent_id: "bob", kind: "to" }], created_at: "2025-01-01T00:00:01Z" })
+      );
+      storage.putMessage(
+        makeMessage({ id: "m2", recipients: [{ agent_id: "bob", kind: "to" }], created_at: "2025-01-01T00:00:02Z" })
+      );
+      storage.putMessage(
+        makeMessage({ id: "m3", recipients: [{ agent_id: "alice", kind: "to" }] })
+      );
+
+      const inbox = storage.getInbox("bob");
+      expect(inbox).toHaveLength(2);
+    });
+
+    it("should filter unread only", () => {
+      storage.putMessage(
+        makeMessage({
+          id: "m1",
+          recipients: [{ agent_id: "bob", kind: "to", read_at: "2025-01-01T00:00:05Z" }],
+        })
+      );
+      storage.putMessage(
+        makeMessage({
+          id: "m2",
+          recipients: [{ agent_id: "bob", kind: "to" }],
+        })
+      );
+
+      const unread = storage.getInbox("bob", { unreadOnly: true });
+      expect(unread).toHaveLength(1);
+      expect(unread[0].id).toBe("m2");
+    });
+
+    it("should get thread by tag", () => {
+      storage.putMessage(makeMessage({ id: "m1", thread_tag: "sprint-1", scope: "default" }));
+      storage.putMessage(makeMessage({ id: "m2", thread_tag: "sprint-1", scope: "default" }));
+      storage.putMessage(makeMessage({ id: "m3", thread_tag: "sprint-2", scope: "default" }));
+
+      const thread = storage.getThread({ threadTag: "sprint-1", scope: "default" });
+      expect(thread).toHaveLength(2);
+    });
+
+    it("should update message recipients on re-put", () => {
+      const msg = makeMessage({
+        recipients: [{ agent_id: "bob", kind: "to" }],
+      });
+      storage.putMessage(msg);
+
+      msg.recipients[0].read_at = "2025-01-01T01:00:00Z";
+      storage.putMessage(msg);
+
+      const result = storage.getMessage("msg-1")!;
+      expect(result.recipients[0].read_at).toBe("2025-01-01T01:00:00Z");
+    });
+  });
+
+  describe("Full-text search", () => {
+    it("should find messages by text content", () => {
+      storage.putMessage(
+        makeMessage({ id: "m1", content: { type: "text", text: "fix the auth bug" } })
+      );
+      storage.putMessage(
+        makeMessage({ id: "m2", content: { type: "text", text: "deploy the app" } })
+      );
+
+      const results = storage.searchMessages("auth");
+      expect(results).toHaveLength(1);
+      expect(results[0].id).toBe("m1");
+    });
+
+    it("should find messages by subject", () => {
+      storage.putMessage(
+        makeMessage({ id: "m1", subject: "auth issue", content: { type: "text", text: "details" } })
+      );
+      storage.putMessage(
+        makeMessage({ id: "m2", subject: "deploy plan", content: { type: "text", text: "steps" } })
+      );
+
+      const results = storage.searchMessages("auth");
+      expect(results).toHaveLength(1);
+    });
+
+    it("should filter search by scope", () => {
+      storage.putMessage(
+        makeMessage({ id: "m1", scope: "team-a", content: { type: "text", text: "auth fix" } })
+      );
+      storage.putMessage(
+        makeMessage({ id: "m2", scope: "team-b", content: { type: "text", text: "auth fix" } })
+      );
+
+      const results = storage.searchMessages("auth", "team-a");
+      expect(results).toHaveLength(1);
+      expect(results[0].scope).toBe("team-a");
+    });
+  });
+
+  describe("Conversations", () => {
+    it("should store and retrieve with participants", () => {
+      const conv: Conversation = {
+        id: "conv-1",
+        scope: "default",
+        subject: "Test",
+        status: "active",
+        participants: [
+          { agent_id: "alice", joined_at: "2025-01-01T00:00:00Z" },
+          { agent_id: "bob", joined_at: "2025-01-01T00:00:00Z" },
+        ],
+        metadata: {},
+        created_at: "2025-01-01T00:00:00Z",
+        updated_at: "2025-01-01T00:00:00Z",
+      };
+      storage.putConversation(conv);
+      const result = storage.getConversation("conv-1")!;
+      expect(result.subject).toBe("Test");
+      expect(result.participants).toHaveLength(2);
+    });
+  });
+
+  describe("Turns & Threads", () => {
+    it("should add and retrieve turns", () => {
+      const turn: Turn = {
+        id: "turn-1",
+        conversation_id: "conv-1",
+        participant_id: "alice",
+        content_type: "text",
+        content: { type: "text", text: "hello" },
+        created_at: "2025-01-01T00:00:00Z",
+      };
+      // Need conversation first for FK
+      storage.putConversation({
+        id: "conv-1", scope: "default", status: "active", participants: [],
+        metadata: {}, created_at: "2025-01-01T00:00:00Z", updated_at: "2025-01-01T00:00:00Z",
+      });
+      storage.addTurn(turn);
+      const turns = storage.getTurns("conv-1");
+      expect(turns).toHaveLength(1);
+      expect(turns[0].participant_id).toBe("alice");
+    });
+
+    it("should store and retrieve threads", () => {
+      storage.putConversation({
+        id: "conv-1", scope: "default", status: "active", participants: [],
+        metadata: {}, created_at: "2025-01-01T00:00:00Z", updated_at: "2025-01-01T00:00:00Z",
+      });
+      storage.putThread({
+        id: "thread-1",
+        conversation_id: "conv-1",
+        root_turn_id: "turn-1",
+        created_at: "2025-01-01T00:00:00Z",
+      });
+      const threads = storage.getThreadsByConversation("conv-1");
+      expect(threads).toHaveLength(1);
+      expect(threads[0].root_turn_id).toBe("turn-1");
+    });
+  });
+});

package/references/agent-inbox/test/storage.test.ts

@@ -0,0 +1,196 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { InMemoryStorage } from "../src/storage/memory.js";
+import type { Agent, Message, Recipient, Conversation, Turn } from "../src/types.js";
+
+function makeAgent(overrides: Partial<Agent> = {}): Agent {
+  return {
+    agent_id: "agent-1",
+    scope: "default",
+    status: "active",
+    metadata: {},
+    registered_at: "2025-01-01T00:00:00Z",
+    last_active_at: "2025-01-01T00:00:00Z",
+    ...overrides,
+  };
+}
+
+function makeMessage(overrides: Partial<Message> = {}): Message {
+  return {
+    id: "msg-1",
+    scope: "default",
+    sender_id: "agent-1",
+    recipients: [{ agent_id: "agent-2", kind: "to" }],
+    content: { type: "text", text: "hello" },
+    importance: "normal",
+    metadata: {},
+    created_at: "2025-01-01T00:00:00Z",
+    ...overrides,
+  };
+}
+
+describe("InMemoryStorage", () => {
+  let storage: InMemoryStorage;
+
+  beforeEach(() => {
+    storage = new InMemoryStorage();
+  });
+
+  describe("Agents", () => {
+    it("should put and get an agent", () => {
+      const agent = makeAgent();
+      storage.putAgent(agent);
+      expect(storage.getAgent("agent-1")).toEqual(agent);
+    });
+
+    it("should return undefined for missing agent", () => {
+      expect(storage.getAgent("nope")).toBeUndefined();
+    });
+
+    it("should list agents by scope", () => {
+      storage.putAgent(makeAgent({ agent_id: "a1", scope: "team-a" }));
+      storage.putAgent(makeAgent({ agent_id: "a2", scope: "team-b" }));
+      storage.putAgent(makeAgent({ agent_id: "a3", scope: "team-a" }));
+
+      expect(storage.listAgents("team-a")).toHaveLength(2);
+      expect(storage.listAgents("team-b")).toHaveLength(1);
+      expect(storage.listAgents()).toHaveLength(3);
+    });
+
+    it("should remove an agent", () => {
+      storage.putAgent(makeAgent());
+      expect(storage.removeAgent("agent-1")).toBe(true);
+      expect(storage.getAgent("agent-1")).toBeUndefined();
+      expect(storage.removeAgent("agent-1")).toBe(false);
+    });
+  });
+
+  describe("Messages", () => {
+    it("should put and get a message", () => {
+      const msg = makeMessage();
+      storage.putMessage(msg);
+      expect(storage.getMessage("msg-1")).toEqual(msg);
+    });
+
+    it("should get inbox for agent", () => {
+      storage.putMessage(
+        makeMessage({
+          id: "m1",
+          recipients: [{ agent_id: "bob", kind: "to" }],
+          created_at: "2025-01-01T00:00:01Z",
+        })
+      );
+      storage.putMessage(
+        makeMessage({
+          id: "m2",
+          recipients: [{ agent_id: "bob", kind: "to" }],
+          created_at: "2025-01-01T00:00:02Z",
+        })
+      );
+      storage.putMessage(
+        makeMessage({
+          id: "m3",
+          recipients: [{ agent_id: "alice", kind: "to" }],
+        })
+      );
+
+      const inbox = storage.getInbox("bob");
+      expect(inbox).toHaveLength(2);
+      expect(inbox[0].id).toBe("m1");
+      expect(inbox[1].id).toBe("m2");
+    });
+
+    it("should filter unread only", () => {
+      storage.putMessage(
+        makeMessage({
+          id: "m1",
+          recipients: [{ agent_id: "bob", kind: "to", read_at: "2025-01-01T00:00:05Z" }],
+        })
+      );
+      storage.putMessage(
+        makeMessage({
+          id: "m2",
+          recipients: [{ agent_id: "bob", kind: "to" }],
+        })
+      );
+
+      const unread = storage.getInbox("bob", { unreadOnly: true });
+      expect(unread).toHaveLength(1);
+      expect(unread[0].id).toBe("m2");
+    });
+
+    it("should get thread by tag", () => {
+      storage.putMessage(makeMessage({ id: "m1", thread_tag: "sprint-1", scope: "default" }));
+      storage.putMessage(makeMessage({ id: "m2", thread_tag: "sprint-1", scope: "default" }));
+      storage.putMessage(makeMessage({ id: "m3", thread_tag: "sprint-2", scope: "default" }));
+
+      const thread = storage.getThread({ threadTag: "sprint-1", scope: "default" });
+      expect(thread).toHaveLength(2);
+    });
+
+    it("should search messages by text content", () => {
+      storage.putMessage(makeMessage({ id: "m1", content: { type: "text", text: "fix the auth bug" } }));
+      storage.putMessage(makeMessage({ id: "m2", content: { type: "text", text: "deploy the app" } }));
+      storage.putMessage(makeMessage({ id: "m3", subject: "auth issue", content: { type: "text", text: "details" } }));
+
+      expect(storage.searchMessages("auth")).toHaveLength(2);
+      expect(storage.searchMessages("deploy")).toHaveLength(1);
+      expect(storage.searchMessages("nonexistent")).toHaveLength(0);
+    });
+
+    it("should get sent messages", () => {
+      storage.putMessage(makeMessage({ id: "m1", sender_id: "alice" }));
+      storage.putMessage(makeMessage({ id: "m2", sender_id: "bob" }));
+      storage.putMessage(makeMessage({ id: "m3", sender_id: "alice" }));
+
+      expect(storage.getSentMessages("alice")).toHaveLength(2);
+      expect(storage.getSentMessages("bob")).toHaveLength(1);
+    });
+  });
+
+  describe("Conversations", () => {
+    it("should put and get a conversation", () => {
+      const conv: Conversation = {
+        id: "conv-1",
+        scope: "default",
+        subject: "Test",
+        status: "active",
+        participants: [],
+        metadata: {},
+        created_at: "2025-01-01T00:00:00Z",
+        updated_at: "2025-01-01T00:00:00Z",
+      };
+      storage.putConversation(conv);
+      expect(storage.getConversation("conv-1")).toEqual(conv);
+    });
+
+    it("should list conversations by scope", () => {
+      storage.putConversation({
+        id: "c1", scope: "team-a", status: "active", participants: [],
+        metadata: {}, created_at: "2025-01-01T00:00:00Z", updated_at: "2025-01-01T00:00:00Z",
+      });
+      storage.putConversation({
+        id: "c2", scope: "team-b", status: "active", participants: [],
+        metadata: {}, created_at: "2025-01-01T00:00:00Z", updated_at: "2025-01-01T00:00:00Z",
+      });
+
+      expect(storage.listConversations("team-a")).toHaveLength(1);
+      expect(storage.listConversations()).toHaveLength(2);
+    });
+  });
+
+  describe("Turns", () => {
+    it("should add and retrieve turns", () => {
+      const turn: Turn = {
+        id: "turn-1",
+        conversation_id: "conv-1",
+        participant_id: "agent-1",
+        content_type: "text",
+        content: { type: "text", text: "hello" },
+        created_at: "2025-01-01T00:00:00Z",
+      };
+      storage.addTurn(turn);
+      expect(storage.getTurns("conv-1")).toHaveLength(1);
+      expect(storage.getTurns("conv-2")).toHaveLength(0);
+    });
+  });
+});

package/references/agent-inbox/test/traceability.test.ts

@@ -0,0 +1,123 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { EventEmitter } from "node:events";
+import { InMemoryStorage } from "../src/storage/memory.js";
+import { MessageRouter } from "../src/router/message-router.js";
+import { TraceabilityLayer } from "../src/traceability/traceability.js";
+
+describe("TraceabilityLayer", () => {
+  let storage: InMemoryStorage;
+  let events: EventEmitter;
+  let router: MessageRouter;
+
+  beforeEach(() => {
+    storage = new InMemoryStorage();
+    events = new EventEmitter();
+    router = new MessageRouter(storage, events, "default");
+    // TraceabilityLayer subscribes to events on construction
+    new TraceabilityLayer(storage, events);
+  });
+
+  it("should auto-create a conversation from thread_tag", async () => {
+    await router.routeMessage({
+      from: "alice",
+      to: "bob",
+      payload: "hello",
+      threadTag: "sprint-1",
+    });
+
+    const conversations = storage.listConversations("default");
+    expect(conversations).toHaveLength(1);
+    expect(conversations[0].subject).toBe("sprint-1");
+    expect(conversations[0].participants).toHaveLength(2);
+  });
+
+  it("should reuse conversation for same thread_tag+scope", async () => {
+    await router.routeMessage({
+      from: "alice",
+      to: "bob",
+      payload: "msg 1",
+      threadTag: "sprint-1",
+    });
+    await router.routeMessage({
+      from: "bob",
+      to: "alice",
+      payload: "msg 2",
+      threadTag: "sprint-1",
+    });
+
+    const conversations = storage.listConversations("default");
+    expect(conversations).toHaveLength(1);
+
+    const turns = storage.getTurns(conversations[0].id);
+    expect(turns).toHaveLength(2);
+  });
+
+  it("should create catch-all conversation for untagged messages", async () => {
+    await router.routeMessage({
+      from: "alice",
+      to: "bob",
+      payload: "hi",
+    });
+
+    const conversations = storage.listConversations("default");
+    expect(conversations).toHaveLength(1);
+    expect(conversations[0].subject).toBe("General");
+  });
+
+  it("should set conversation_id on messages", async () => {
+    const msg = await router.routeMessage({
+      from: "alice",
+      to: "bob",
+      payload: "hello",
+      threadTag: "test",
+    });
+
+    // The traceability layer sets conversation_id after message.created
+    const updated = storage.getMessage(msg.id)!;
+    expect(updated.conversation_id).toBeTruthy();
+  });
+
+  it("should create threads from reply chains", async () => {
+    const msg1 = await router.routeMessage({
+      from: "alice",
+      to: "bob",
+      payload: "original",
+      threadTag: "test",
+    });
+
+    const msg2 = await router.routeMessage({
+      from: "bob",
+      to: "alice",
+      payload: "reply",
+      inReplyTo: msg1.id,
+      threadTag: "test",
+    });
+
+    const conversations = storage.listConversations("default");
+    expect(conversations).toHaveLength(1);
+
+    const threads = storage.getThreadsByConversation(conversations[0].id);
+    expect(threads).toHaveLength(1);
+
+    const turns = storage.getTurns(conversations[0].id);
+    expect(turns).toHaveLength(2);
+    // The reply turn should have a thread_id
+    const replyTurn = turns.find((t) => t.source_message_id === msg2.id);
+    expect(replyTurn?.thread_id).toBeTruthy();
+  });
+
+  it("should add participants from both sender and recipients", async () => {
+    await router.routeMessage({
+      from: "alice",
+      to: ["bob", "charlie"],
+      payload: "team update",
+      threadTag: "standup",
+    });
+
+    const conv = storage.listConversations("default")[0];
+    const participantIds = conv.participants.map((p) => p.agent_id);
+    expect(participantIds).toContain("alice");
+    expect(participantIds).toContain("bob");
+    expect(participantIds).toContain("charlie");
+  });
+});