agent-inbox 0.0.1 → 0.1.1

package/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/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");
+  });
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "test"]
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["cjs", "esm"],
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+});

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["test/**/*.test.ts"],
+    testTimeout: 10_000,
+  },
+});

package/dist/index.d.mts

@@ -1,2 +0,0 @@
-
-export {  }

package/dist/index.mjs

@@ -1 +0,0 @@
-//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}