macro-agent 0.1.1 → 0.1.3

package/src/api/__tests__/conversation-api.test.ts

@@ -1,468 +0,0 @@
-/**
- * Conversation API Tests
- *
- * Tests for the conversation REST endpoints added in Phase 5.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import request from "supertest";
-import { createEventStore, type EventStore } from "../../store/event-store.js";
-import { createMailService, type MailService } from "../../mail/mail-service.js";
-import { createConversationMap, type ConversationMap } from "../../mail/conversation-map.js";
-import { createAPIServer, type APIServer, type APIServices } from "../server.js";
-
-// Minimal mock services for API tests
-function createMockAgentManager() {
-  const agents: any[] = [];
-  return {
-    list: () => agents,
-    get: (id: string) => agents.find((a) => a.id === id) ?? null,
-    getChildren: () => [],
-    getHierarchy: () => null,
-    getOrCreateHeadManager: async (opts: any) => ({
-      id: "hm-1",
-      session_id: "session-1",
-    }),
-    getSession: () => null,
-    hasActiveSession: () => false,
-    isPrompting: () => false,
-    supportsInjection: async () => false,
-    isProcessRunning: () => false,
-    prompt: async function* () {},
-    promptUntilDone: async () => ({ doneCalled: false, updates: [] }),
-    spawn: async () => ({ agent_id: "a-1", session_id: "s-1", id: "a-1" }),
-    terminate: async () => {},
-    resume: async () => ({ agent_id: "a-1", session_id: "s-1", id: "a-1" }),
-    respondToPermission: () => false,
-    cancelPermission: () => false,
-    onLifecycleEvent: () => () => {},
-    listHeadManagers: () => [],
-    setMailServices: () => {},
-    close: async () => {},
-  };
-}
-
-function createMockTaskManager() {
-  return {
-    list: () => [],
-    get: () => null,
-    create: () => ({ id: "t-1" }),
-    updateStatus: () => {},
-  };
-}
-
-function createMockMessageRouter() {
-  return {
-    sendToAddress: async () => ({ id: "e-1", from: "a-1", to: {}, content: "", timestamp: 0, delivered: [] }),
-    emitStatus: () => {},
-    getMessages: () => [],
-    getFullMessage: () => null,
-    acknowledgeMessage: () => {},
-    acknowledgeMessages: () => {},
-    subscribe: () => {},
-    unsubscribe: () => {},
-    getSubscriptions: () => [],
-    getSubscribers: () => [],
-    setupDefaultSubscriptions: () => {},
-    setTurnRecorder: () => {},
-  };
-}
-
-describe("Conversation API", () => {
-  let eventStore: EventStore;
-  let mailService: MailService;
-  let server: APIServer;
-
-  beforeEach(async () => {
-    eventStore = await createEventStore({ inMemory: true });
-    mailService = createMailService({ eventStore });
-
-    const services: APIServices = {
-      eventStore,
-      agentManager: createMockAgentManager() as any,
-      taskManager: createMockTaskManager() as any,
-      messageRouter: createMockMessageRouter() as any,
-      mailService,
-    };
-
-    server = createAPIServer(services, { port: 0 });
-  });
-
-  afterEach(async () => {
-    await eventStore.close();
-  });
-
-  describe("GET /api/conversations", () => {
-    it("should return empty list when no conversations", async () => {
-      const res = await request(server.app).get("/api/conversations");
-      expect(res.status).toBe(200);
-      expect(res.body.conversations).toEqual([]);
-      expect(res.body.total).toBe(0);
-    });
-
-    it("should list created conversations", async () => {
-      mailService.createConversation({
-        type: "session",
-        subject: "Test session",
-        createdBy: "user",
-      });
-      mailService.createConversation({
-        type: "task",
-        subject: "Test task",
-        createdBy: "agent-1",
-      });
-
-      const res = await request(server.app).get("/api/conversations");
-      expect(res.status).toBe(200);
-      expect(res.body.conversations).toHaveLength(2);
-      expect(res.body.total).toBe(2);
-    });
-
-    it("should filter by type", async () => {
-      mailService.createConversation({
-        type: "session",
-        subject: "Session",
-        createdBy: "user",
-      });
-      mailService.createConversation({
-        type: "task",
-        subject: "Task",
-        createdBy: "agent",
-      });
-
-      const res = await request(server.app).get("/api/conversations?type=session");
-      expect(res.status).toBe(200);
-      expect(res.body.conversations).toHaveLength(1);
-      expect(res.body.conversations[0].type).toBe("session");
-    });
-
-    it("should support pagination", async () => {
-      for (let i = 0; i < 5; i++) {
-        mailService.createConversation({
-          type: "task",
-          subject: `Task ${i}`,
-          createdBy: "agent",
-        });
-      }
-
-      const res = await request(server.app).get("/api/conversations?limit=2&offset=1");
-      expect(res.status).toBe(200);
-      expect(res.body.conversations).toHaveLength(2);
-      expect(res.body.total).toBe(5);
-    });
-  });
-
-  describe("GET /api/conversations/:id", () => {
-    it("should return conversation detail", async () => {
-      const { conversationId } = mailService.createConversation({
-        type: "session",
-        subject: "My session",
-        createdBy: "user",
-      });
-
-      const res = await request(server.app).get(`/api/conversations/${conversationId}`);
-      expect(res.status).toBe(200);
-      expect(res.body.id).toBe(conversationId);
-      expect(res.body.type).toBe("session");
-      expect(res.body.subject).toBe("My session");
-      expect(res.body.status).toBe("active");
-    });
-
-    it("should return 404 for non-existent conversation", async () => {
-      const res = await request(server.app).get("/api/conversations/nonexistent");
-      expect(res.status).toBe(404);
-      expect(res.body.code).toBe("CONVERSATION_NOT_FOUND");
-    });
-  });
-
-  describe("GET /api/conversations/:id/turns", () => {
-    it("should list turns for a conversation", async () => {
-      const { conversationId } = mailService.createConversation({
-        type: "session",
-        subject: "Session",
-        createdBy: "user",
-      });
-
-      mailService.recordTurn({
-        conversationId,
-        participant: "user",
-        contentType: "text",
-        content: "Hello",
-      });
-
-      mailService.recordTurn({
-        conversationId,
-        participant: "agent-1",
-        contentType: "text",
-        content: "Hi there!",
-      });
-
-      const res = await request(server.app).get(`/api/conversations/${conversationId}/turns`);
-      expect(res.status).toBe(200);
-      expect(res.body.turns).toHaveLength(2);
-      expect(res.body.total).toBe(2);
-      expect(res.body.turns[0].participant).toBe("user");
-      expect(res.body.turns[0].content).toBe("Hello");
-      expect(res.body.turns[1].participant).toBe("agent-1");
-    });
-
-    it("should return 404 for non-existent conversation", async () => {
-      const res = await request(server.app).get("/api/conversations/nonexistent/turns");
-      expect(res.status).toBe(404);
-    });
-
-    it("should support pagination", async () => {
-      const { conversationId } = mailService.createConversation({
-        type: "session",
-        subject: "Session",
-        createdBy: "user",
-      });
-
-      for (let i = 0; i < 5; i++) {
-        mailService.recordTurn({
-          conversationId,
-          participant: "user",
-          contentType: "text",
-          content: `Message ${i}`,
-        });
-      }
-
-      const res = await request(server.app).get(`/api/conversations/${conversationId}/turns?limit=2&offset=1`);
-      expect(res.status).toBe(200);
-      expect(res.body.turns).toHaveLength(2);
-      expect(res.body.total).toBe(5);
-    });
-  });
-
-  describe("POST /api/conversations/:id/close", () => {
-    it("should close an active conversation", async () => {
-      const { conversationId } = mailService.createConversation({
-        type: "session",
-        subject: "Session",
-        createdBy: "user",
-      });
-
-      const res = await request(server.app)
-        .post(`/api/conversations/${conversationId}/close`)
-        .send({ reason: "completed" });
-
-      expect(res.status).toBe(200);
-      expect(res.body.success).toBe(true);
-
-      // Verify it's closed
-      const conv = mailService.getConversation(conversationId);
-      expect(conv!.status).toBe("completed");
-    });
-
-    it("should return 404 for non-existent conversation", async () => {
-      const res = await request(server.app)
-        .post("/api/conversations/nonexistent/close")
-        .send({});
-      expect(res.status).toBe(404);
-    });
-
-    it("should reject closing already-closed conversation", async () => {
-      const { conversationId } = mailService.createConversation({
-        type: "session",
-        subject: "Session",
-        createdBy: "user",
-      });
-      mailService.closeConversation({
-        conversationId,
-        closedBy: "user",
-        reason: "completed",
-      });
-
-      const res = await request(server.app)
-        .post(`/api/conversations/${conversationId}/close`)
-        .send({});
-      expect(res.status).toBe(400);
-      expect(res.body.code).toBe("ALREADY_CLOSED");
-    });
-  });
-
-  describe("GET /api/conversations/:id/participants", () => {
-    it("should list participants", async () => {
-      const { conversationId } = mailService.createConversation({
-        type: "task",
-        subject: "Task",
-        createdBy: "parent-1",
-      });
-      mailService.joinConversation({
-        conversationId,
-        participantId: "parent-1",
-        role: "initiator",
-      });
-      mailService.joinConversation({
-        conversationId,
-        participantId: "child-1",
-        role: "worker",
-      });
-
-      const res = await request(server.app).get(`/api/conversations/${conversationId}/participants`);
-      expect(res.status).toBe(200);
-      expect(res.body.participants).toHaveLength(2);
-      expect(res.body.total).toBe(2);
-    });
-
-    it("should return 404 for non-existent conversation", async () => {
-      const res = await request(server.app).get("/api/conversations/nonexistent/participants");
-      expect(res.status).toBe(404);
-    });
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────
-// POST /api/init and POST /api/conversation/message mail side effects
-// ─────────────────────────────────────────────────────────────────
-
-describe("API Mail Side Effects", () => {
-  let eventStore: EventStore;
-  let mailService: MailService;
-  let conversationMap: ConversationMap;
-  let server: APIServer;
-
-  function createPromptableAgentManager() {
-    const agents: any[] = [];
-    return {
-      list: () => agents,
-      get: (id: string) => agents.find((a: any) => a.id === id) ?? null,
-      getChildren: () => [],
-      getHierarchy: () => null,
-      getOrCreateHeadManager: async () => ({
-        id: "hm-test",
-        session_id: "session-hm-test",
-      }),
-      getSession: () => null,
-      hasActiveSession: () => false,
-      isPrompting: () => false,
-      supportsInjection: async () => false,
-      isProcessRunning: () => false,
-      prompt: async function* () {
-        yield {
-          sessionUpdate: "agent_message_chunk",
-          content: { type: "text", text: "Agent response" },
-        };
-      },
-      promptUntilDone: async () => ({ doneCalled: false, updates: [] }),
-      spawn: async () => ({ agent_id: "a-1", session_id: "s-1", id: "a-1" }),
-      terminate: async () => {},
-      resume: async () => ({ agent_id: "a-1", session_id: "s-1", id: "a-1" }),
-      respondToPermission: () => false,
-      cancelPermission: () => false,
-      onLifecycleEvent: () => () => {},
-      listHeadManagers: () => [],
-      setMailServices: () => {},
-      close: async () => {},
-    };
-  }
-
-  beforeEach(async () => {
-    eventStore = await createEventStore({ inMemory: true });
-    mailService = createMailService({ eventStore });
-    conversationMap = createConversationMap();
-
-    const services: APIServices = {
-      eventStore,
-      agentManager: createPromptableAgentManager() as any,
-      taskManager: createMockTaskManager() as any,
-      messageRouter: createMockMessageRouter() as any,
-      mailService,
-      conversationMap,
-    };
-
-    server = createAPIServer(services, { port: 0 });
-  });
-
-  afterEach(async () => {
-    await eventStore.close();
-  });
-
-  describe("POST /api/init mail side effects", () => {
-    it("should create session conversation on init", async () => {
-      const res = await request(server.app)
-        .post("/api/init")
-        .send({ cwd: "/tmp" });
-
-      expect(res.status).toBe(200);
-      expect(res.body.success).toBe(true);
-      expect(res.body.head_manager_id).toBe("hm-test");
-
-      // Verify session conversation created
-      const convs = mailService.listConversations({ type: "session" });
-      expect(convs).toHaveLength(1);
-      expect(convs[0].subject).toBe("User session");
-      expect(convs[0].status).toBe("active");
-
-      // Verify HM joined as worker
-      const participants = mailService.listParticipants(convs[0].id);
-      expect(participants).toHaveLength(1);
-      expect(participants[0].id).toBe("hm-test");
-      expect(participants[0].role).toBe("worker");
-
-      // Verify conversationMap wired
-      expect(conversationMap.getSessionConversation("hm-test")).toBe(convs[0].id);
-    });
-  });
-
-  describe("POST /api/conversation/message mail side effects", () => {
-    it("should record user and assistant turns in session conversation", async () => {
-      // First init
-      await request(server.app)
-        .post("/api/init")
-        .send({ cwd: "/tmp" });
-
-      const sessionConvId = conversationMap.getSessionConversation("hm-test")!;
-      expect(sessionConvId).toBeDefined();
-
-      // Send message
-      const res = await request(server.app)
-        .post("/api/conversation/message")
-        .send({ message: "Hello agent" });
-
-      expect(res.status).toBe(200);
-      expect(res.body.content).toBe("Agent response");
-
-      // Verify turns recorded
-      const turns = mailService.listTurns({ conversationId: sessionConvId });
-      expect(turns).toHaveLength(2);
-
-      // User turn
-      expect(turns[0].participant).toBe("user");
-      expect(turns[0].content).toBe("Hello agent");
-      expect(turns[0].contentType).toBe("text");
-
-      // Assistant turn
-      expect(turns[1].participant).toBe("hm-test");
-      expect(turns[1].content).toBe("Agent response");
-      expect(turns[1].contentType).toBe("text");
-    });
-
-    it("should record multiple exchanges in session conversation", async () => {
-      await request(server.app)
-        .post("/api/init")
-        .send({ cwd: "/tmp" });
-
-      const sessionConvId = conversationMap.getSessionConversation("hm-test")!;
-
-      // Send two messages
-      await request(server.app)
-        .post("/api/conversation/message")
-        .send({ message: "First question" });
-
-      await request(server.app)
-        .post("/api/conversation/message")
-        .send({ message: "Second question" });
-
-      const turns = mailService.listTurns({ conversationId: sessionConvId });
-      // 2 exchanges × 2 turns = 4 turns
-      expect(turns).toHaveLength(4);
-      expect(turns[0].participant).toBe("user");
-      expect(turns[0].content).toBe("First question");
-      expect(turns[1].participant).toBe("hm-test");
-      expect(turns[2].participant).toBe("user");
-      expect(turns[2].content).toBe("Second question");
-      expect(turns[3].participant).toBe("hm-test");
-    });
-  });
-});

package/src/cli/__tests__/acp.test.ts

@@ -1,214 +0,0 @@
-/**
- * ACP CLI tests
- *
- * Tests for the ACP CLI entry point, including argument parsing
- * and combined server configuration.
- */
-
-import { describe, it, expect } from "vitest";
-import { parseArgs, type ACPServerOptions } from "../parse-args.js";
-
-// ─────────────────────────────────────────────────────────────────
-// parseArgs Tests
-// ─────────────────────────────────────────────────────────────────
-
-describe("parseArgs", () => {
-  describe("--cwd option", () => {
-    it("should parse --cwd option", () => {
-      const result = parseArgs(["--cwd", "/path/to/project"]);
-      expect(result.cwd).toBe("/path/to/project");
-    });
-
-    it("should not set cwd if no value provided", () => {
-      const result = parseArgs(["--cwd"]);
-      expect(result.cwd).toBeUndefined();
-    });
-
-    it("should handle cwd with spaces in path", () => {
-      const result = parseArgs(["--cwd", "/path/with spaces/project"]);
-      expect(result.cwd).toBe("/path/with spaces/project");
-    });
-  });
-
-  describe("--acp option", () => {
-    it("should parse --acp flag", () => {
-      const result = parseArgs(["--acp"]);
-      expect(result.acp).toBe(true);
-    });
-
-    it("should not set acp if flag not provided (default is full server mode)", () => {
-      const result = parseArgs([]);
-      expect(result.acp).toBeUndefined();
-    });
-  });
-
-  describe("--port option", () => {
-    it("should parse --port option", () => {
-      const result = parseArgs(["--port", "8080"]);
-      expect(result.port).toBe(8080);
-    });
-
-    it("should not set port if no value provided", () => {
-      const result = parseArgs(["--port"]);
-      expect(result.port).toBeUndefined();
-    });
-
-    it("should handle port as integer", () => {
-      const result = parseArgs(["--port", "3000"]);
-      expect(result.port).toBe(3000);
-      expect(typeof result.port).toBe("number");
-    });
-  });
-
-  describe("--host option", () => {
-    it("should parse --host option", () => {
-      const result = parseArgs(["--host", "0.0.0.0"]);
-      expect(result.host).toBe("0.0.0.0");
-    });
-
-    it("should not set host if no value provided", () => {
-      const result = parseArgs(["--host"]);
-      expect(result.host).toBeUndefined();
-    });
-
-    it("should handle localhost", () => {
-      const result = parseArgs(["--host", "localhost"]);
-      expect(result.host).toBe("localhost");
-    });
-  });
-
-  describe("combined options", () => {
-    it("should parse all options together", () => {
-      const result = parseArgs([
-        "--cwd", "/project",
-        "--acp",
-        "--port", "9000",
-        "--host", "127.0.0.1",
-      ]);
-
-      expect(result).toEqual({
-        cwd: "/project",
-        acp: true,
-        port: 9000,
-        host: "127.0.0.1",
-      });
-    });
-
-    it("should parse options in any order", () => {
-      const result = parseArgs([
-        "--acp",
-        "--host", "0.0.0.0",
-        "--cwd", "/my/project",
-        "--port", "4000",
-      ]);
-
-      expect(result).toEqual({
-        cwd: "/my/project",
-        acp: true,
-        port: 4000,
-        host: "0.0.0.0",
-      });
-    });
-
-    it("should parse server options without --acp (full server mode)", () => {
-      const result = parseArgs(["--port", "5000", "--host", "0.0.0.0"]);
-
-      expect(result).toEqual({
-        port: 5000,
-        host: "0.0.0.0",
-      });
-    });
-
-    it("should parse --acp with --cwd (stdio ACP mode)", () => {
-      const result = parseArgs(["--acp", "--cwd", "/project"]);
-
-      expect(result).toEqual({
-        acp: true,
-        cwd: "/project",
-      });
-    });
-  });
-
-  describe("edge cases", () => {
-    it("should return empty object for no arguments (defaults to full server mode)", () => {
-      const result = parseArgs([]);
-      expect(result).toEqual({});
-    });
-
-    it("should ignore unknown options", () => {
-      const result = parseArgs(["--unknown", "value", "--acp"]);
-      expect(result.acp).toBe(true);
-      expect(result).not.toHaveProperty("unknown");
-    });
-
-    it("should use process.argv when no args provided", () => {
-      // Save original argv
-      const originalArgv = process.argv;
-
-      try {
-        process.argv = ["node", "acp.js", "--acp", "--port", "7777"];
-        const result = parseArgs();
-        expect(result.acp).toBe(true);
-        expect(result.port).toBe(7777);
-      } finally {
-        // Restore original argv
-        process.argv = originalArgv;
-      }
-    });
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────
-// Server Mode Tests
-// ─────────────────────────────────────────────────────────────────
-
-describe("Server Mode Configuration", () => {
-  describe("default behavior (full server mode)", () => {
-    it("should run full server mode when no --acp flag is set", () => {
-      const options = parseArgs([]);
-      expect(options.acp).toBeUndefined();
-      // When acp is undefined, main() runs full server mode
-    });
-
-    it("should use specified port in full server mode", () => {
-      const options = parseArgs(["--port", "8080"]);
-      expect(options.acp).toBeUndefined();
-      expect(options.port).toBe(8080);
-    });
-
-    it("should use specified host in full server mode", () => {
-      const options = parseArgs(["--host", "0.0.0.0"]);
-      expect(options.acp).toBeUndefined();
-      expect(options.host).toBe("0.0.0.0");
-    });
-  });
-
-  describe("stdio ACP mode (--acp flag)", () => {
-    it("should enable stdio ACP mode when --acp flag is set", () => {
-      const options = parseArgs(["--acp"]);
-      expect(options.acp).toBe(true);
-    });
-
-    it("should allow --cwd with --acp for embedded use", () => {
-      const options = parseArgs(["--acp", "--cwd", "/path/to/project"]);
-      expect(options.acp).toBe(true);
-      expect(options.cwd).toBe("/path/to/project");
-    });
-  });
-
-  describe("default values behavior", () => {
-    it("should use default port 3001 when not specified", () => {
-      const options = parseArgs([]);
-      // Default is applied in main(), not parseArgs()
-      expect(options.port).toBeUndefined();
-      // The actual default (3001) is applied when creating the server
-    });
-
-    it("should use default host localhost when not specified", () => {
-      const options = parseArgs([]);
-      // Default is applied in main(), not parseArgs()
-      expect(options.host).toBeUndefined();
-      // The actual default (localhost) is applied when creating the server
-    });
-  });
-});