macro-agent 0.2.5 → 0.2.6

package/src/trigger/__tests__/trigger-system-v2.test.ts

@@ -1,257 +0,0 @@
-/**
- * Tests for Trigger System V2
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { createTriggerSystemV2, type TriggerSystemV2 } from "../trigger-system-v2.js";
-import { AgentStore } from "../../agent/agent-store.js";
-import type { AgentManager } from "../../agent/agent-manager.js";
-import type { InboxAdapter, InboxDeliveryEvent, DeliveryHandler } from "../../adapters/types.js";
-
-// =============================================================================
-// Mocks
-// =============================================================================
-
-function createMockAgentManager(): AgentManager {
-  return {
-    spawn: vi.fn().mockResolvedValue({ id: "agent_new" }),
-    terminate: vi.fn().mockResolvedValue(undefined),
-    get: vi.fn().mockReturnValue(null),
-    list: vi.fn().mockReturnValue([]),
-    getChildren: vi.fn().mockReturnValue([]),
-    getSession: vi.fn().mockReturnValue(null),
-    hasActiveSession: vi.fn().mockReturnValue(false),
-    isPrompting: vi.fn().mockReturnValue(false),
-    prompt: vi.fn().mockReturnValue({
-      [Symbol.asyncIterator]: () => ({
-        next: () => Promise.resolve({ done: true, value: undefined }),
-      }),
-    }),
-    setSpawnInterceptor: vi.fn(),
-    getRoleRegistry: vi.fn(),
-    onLifecycleEvent: vi.fn().mockReturnValue(() => {}),
-    close: vi.fn().mockResolvedValue(undefined),
-    supportsInjection: vi.fn().mockResolvedValue(false),
-  } as unknown as AgentManager;
-}
-
-function createMockInboxAdapter(): InboxAdapter & {
-  _handlers: Set<DeliveryHandler>;
-  _simulateDelivery: (event: InboxDeliveryEvent) => void;
-} {
-  const handlers = new Set<DeliveryHandler>();
-
-  return {
-    registerAgent: vi.fn().mockResolvedValue(undefined),
-    deregisterAgent: vi.fn().mockResolvedValue(undefined),
-    send: vi.fn().mockResolvedValue("msg-1"),
-    onDelivery: vi.fn((handler: DeliveryHandler) => {
-      handlers.add(handler);
-    }),
-    offDelivery: vi.fn((handler: DeliveryHandler) => {
-      handlers.delete(handler);
-    }),
-    checkInbox: vi.fn().mockResolvedValue([]),
-    readThread: vi.fn().mockResolvedValue([]),
-    setSignalFilter: vi.fn(),
-    setEmissionValidator: vi.fn(),
-    socketPath: "/tmp/test-inbox.sock",
-    stop: vi.fn().mockResolvedValue(undefined),
-    _handlers: handlers,
-    _simulateDelivery(event: InboxDeliveryEvent) {
-      for (const handler of handlers) {
-        handler(event);
-      }
-    },
-  } as unknown as InboxAdapter & {
-    _handlers: Set<DeliveryHandler>;
-    _simulateDelivery: (event: InboxDeliveryEvent) => void;
-  };
-}
-
-function makeDeliveryEvent(overrides: Partial<InboxDeliveryEvent> = {}): InboxDeliveryEvent {
-  return {
-    agentId: "worker-1",
-    recipientKind: "to",
-    message: {
-      id: `msg-${Date.now()}`,
-      scope: "default",
-      sender_id: "coordinator-1",
-      recipients: [{ agent_id: "worker-1", kind: "to" }],
-      content: { type: "text", text: "Hello worker" },
-      importance: "normal",
-      metadata: {},
-      created_at: new Date().toISOString(),
-    } as any,
-    ...overrides,
-  };
-}
-
-// =============================================================================
-// Tests
-// =============================================================================
-
-describe("TriggerSystemV2", () => {
-  let agentStore: AgentStore;
-  let agentManager: AgentManager;
-  let inboxAdapter: ReturnType<typeof createMockInboxAdapter>;
-  let system: TriggerSystemV2;
-
-  beforeEach(async () => {
-    agentStore = new AgentStore(":memory:");
-    agentManager = createMockAgentManager();
-    inboxAdapter = createMockInboxAdapter();
-
-    system = createTriggerSystemV2(
-      { agentManager, agentStore, inboxAdapter },
-      { wake: { enableHeartbeat: false } }
-    );
-  });
-
-  afterEach(async () => {
-    await system.stop();
-    agentStore.close();
-  });
-
-  // ── Lifecycle ──────────────────────────────────────────────
-
-  describe("lifecycle", () => {
-    it("should start and stop cleanly", async () => {
-      expect(system.isRunning()).toBe(false);
-
-      await system.start();
-      expect(system.isRunning()).toBe(true);
-
-      await system.stop();
-      expect(system.isRunning()).toBe(false);
-    });
-
-    it("should subscribe to inbox on start and unsubscribe on stop", async () => {
-      await system.start();
-      expect(inboxAdapter.onDelivery).toHaveBeenCalledOnce();
-
-      await system.stop();
-      expect(inboxAdapter.offDelivery).toHaveBeenCalledOnce();
-    });
-
-    it("should handle double start/stop", async () => {
-      await system.start();
-      await system.start(); // no-op
-      expect(system.isRunning()).toBe(true);
-
-      await system.stop();
-      await system.stop(); // no-op
-      expect(system.isRunning()).toBe(false);
-    });
-  });
-
-  // ── Inbox Delivery → Wake ─────────────────────────────────
-
-  describe("inbox delivery → wake", () => {
-    it("should enqueue messages from inbox delivery events", async () => {
-      await system.start();
-
-      inboxAdapter._simulateDelivery(makeDeliveryEvent());
-
-      // Message should be in the queue for worker-1
-      const pending = system.queue.getAgentsWithEvents();
-      expect(pending).toContain("worker-1");
-    });
-
-    it("should request immediate wake for urgent messages", async () => {
-      await system.start();
-
-      // Mock that agent has an active session
-      vi.mocked(agentManager.hasActiveSession).mockReturnValue(true);
-
-      inboxAdapter._simulateDelivery(
-        makeDeliveryEvent({
-          message: {
-            ...makeDeliveryEvent().message,
-            importance: "urgent",
-          } as any,
-        })
-      );
-
-      // Should have enqueued with high priority
-      const pending = system.queue.getAgentsWithEvents();
-      expect(pending).toContain("worker-1");
-    });
-
-    it("should enqueue low-priority messages without waking", async () => {
-      await system.start();
-
-      inboxAdapter._simulateDelivery(
-        makeDeliveryEvent({
-          message: {
-            ...makeDeliveryEvent().message,
-            importance: "low",
-          } as any,
-        })
-      );
-
-      // Should be queued (for next heartbeat or prompt)
-      const pending = system.queue.getAgentsWithEvents();
-      expect(pending).toContain("worker-1");
-    });
-
-    it("should format text content correctly", async () => {
-      await system.start();
-
-      inboxAdapter._simulateDelivery(
-        makeDeliveryEvent({
-          message: {
-            ...makeDeliveryEvent().message,
-            content: { type: "text", text: "Task assigned: implement feature X" },
-            subject: "New Task",
-          } as any,
-        })
-      );
-
-      const events = system.queue.drain("worker-1");
-      expect(events.length).toBeGreaterThanOrEqual(1);
-      expect(events[0].text).toContain("New Task");
-      expect(events[0].text).toContain("Task assigned: implement feature X");
-    });
-
-    it("should format event content correctly", async () => {
-      await system.start();
-
-      inboxAdapter._simulateDelivery(
-        makeDeliveryEvent({
-          message: {
-            ...makeDeliveryEvent().message,
-            content: {
-              type: "event",
-              event: "task_completed",
-              data: { taskId: "t-1" },
-            },
-          } as any,
-        })
-      );
-
-      const events = system.queue.drain("worker-1");
-      expect(events.length).toBeGreaterThanOrEqual(1);
-      expect(events[0].text).toContain("task_completed");
-    });
-
-    it("should not deliver events before start", () => {
-      // System not started — delivery handler not installed
-      inboxAdapter._simulateDelivery(makeDeliveryEvent());
-
-      const pending = system.queue.getAgentsWithEvents();
-      expect(pending).not.toContain("worker-1");
-    });
-  });
-
-  // ── Components ─────────────────────────────────────────────
-
-  describe("components", () => {
-    it("should expose queue, wakeManager, cronService, webhookHandler", () => {
-      expect(system.queue).toBeDefined();
-      expect(system.wakeManager).toBeDefined();
-      expect(system.cronService).toBeDefined();
-      expect(system.webhookHandler).toBeDefined();
-    });
-  });
-});

package/src/trigger/__tests__/wake-manager.test.ts

@@ -1,356 +0,0 @@
-/**
- * Wake Manager Tests
- *
- * Tests for the decoupled wake manager that handles
- * delivering queued events to agents.
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { createWakeManager } from "../wake/wake-manager.js";
-import type { AgentId } from "../../store/types/index.js";
-
-describe("WakeManager", () => {
-  let mockDeps: ReturnType<typeof createMockDeps>;
-  let wakeManager: ReturnType<typeof createWakeManager>;
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-    mockDeps = createMockDeps();
-    wakeManager = createWakeManager(mockDeps, { enableLogging: false });
-  });
-
-  afterEach(() => {
-    wakeManager.stop();
-    vi.useRealTimers();
-  });
-
-  describe("lifecycle", () => {
-    it("should start and stop", () => {
-      expect(wakeManager.isRunning()).toBe(false);
-
-      wakeManager.start();
-      expect(wakeManager.isRunning()).toBe(true);
-
-      wakeManager.stop();
-      expect(wakeManager.isRunning()).toBe(false);
-    });
-
-    it("should be idempotent for start/stop", () => {
-      wakeManager.start();
-      wakeManager.start();
-      expect(wakeManager.isRunning()).toBe(true);
-
-      wakeManager.stop();
-      wakeManager.stop();
-      expect(wakeManager.isRunning()).toBe(false);
-    });
-  });
-
-  describe("requestWakeNow", () => {
-    it("should ignore wake requests when not running", () => {
-      wakeManager.requestWakeNow({ reason: "test" });
-      expect(wakeManager.hasPendingWake()).toBe(false);
-    });
-
-    it("should schedule wake when running", () => {
-      wakeManager.start();
-      wakeManager.requestWakeNow({ reason: "test" });
-      expect(wakeManager.hasPendingWake()).toBe(true);
-    });
-
-    it("should coalesce multiple wake requests", () => {
-      wakeManager.start();
-
-      wakeManager.requestWakeNow({ reason: "first" });
-      wakeManager.requestWakeNow({ reason: "second" });
-      wakeManager.requestWakeNow({ reason: "third" });
-
-      expect(wakeManager.hasPendingWake()).toBe(true);
-      // Last reason is stored (newer reason overrides older)
-      expect(wakeManager.getPendingReason()).toBe("third");
-    });
-
-    it("should run wake cycle after coalesce delay", async () => {
-      mockDeps.systemEventQueue.getAgentsWithEvents = vi
-        .fn()
-        .mockReturnValue(["agent_1" as AgentId]);
-      mockDeps.systemEventQueue.drainText = vi.fn().mockReturnValue(["Event 1"]);
-
-      wakeManager.start();
-      wakeManager.requestWakeNow({ reason: "test" });
-
-      // Advance past default coalesce time (250ms)
-      await vi.advanceTimersByTimeAsync(300);
-
-      expect(mockDeps.systemEventQueue.drainText).toHaveBeenCalledWith(
-        "agent_1",
-        expect.any(Object)
-      );
-    });
-  });
-
-  describe("runWakeCycle", () => {
-    it("should return skipped if wake in progress", async () => {
-      wakeManager.start();
-
-      // Create a long-running inject operation to keep the cycle busy
-      let resolveInject: () => void;
-      const injectPromise = new Promise<{ success: boolean }>((resolve) => {
-        resolveInject = () => resolve({ success: true });
-      });
-
-      const mockSession = {
-        supportsInject: vi.fn().mockReturnValue(true),
-        inject: vi.fn().mockReturnValue(injectPromise),
-      };
-
-      mockDeps.agentManager.getSession = vi.fn().mockReturnValue(mockSession);
-      mockDeps.systemEventQueue.getAgentsWithEvents = vi
-        .fn()
-        .mockReturnValue(["agent_1" as AgentId]);
-      mockDeps.systemEventQueue.drainText = vi.fn().mockReturnValue(["Event"]);
-
-      // Start first cycle (will wait on inject)
-      const firstCyclePromise = wakeManager.runWakeCycle({ reason: "first" });
-
-      // Try to start second cycle immediately
-      const result = await wakeManager.runWakeCycle({ reason: "second" });
-
-      expect(result.status).toBe("skipped");
-      expect(result.reason).toBe("wake-in-progress");
-
-      // Clean up - resolve the pending inject
-      resolveInject!();
-      await firstCyclePromise;
-    });
-
-    it("should deliver events to agents with inject", async () => {
-      const mockSession = {
-        supportsInject: vi.fn().mockReturnValue(true),
-        inject: vi.fn().mockResolvedValue({ success: true }),
-      };
-
-      mockDeps.agentManager.getSession = vi.fn().mockReturnValue(mockSession);
-      mockDeps.systemEventQueue.getAgentsWithEvents = vi
-        .fn()
-        .mockReturnValue(["agent_1" as AgentId]);
-      mockDeps.systemEventQueue.drainText = vi.fn().mockReturnValue(["Event 1", "Event 2"]);
-
-      wakeManager.start();
-      const result = await wakeManager.runWakeCycle({ reason: "test" });
-
-      expect(result.status).toBe("ran");
-      expect(result.wokenAgents).toContain("agent_1");
-      expect(mockSession.inject).toHaveBeenCalled();
-    });
-
-    it("should fall back to interrupt if inject fails", async () => {
-      // Create a mock iterator that completes after first call
-      let callCount = 0;
-      const mockIterator = {
-        next: vi.fn().mockImplementation(() => {
-          callCount++;
-          // First call returns a value, second call ends the iteration
-          return Promise.resolve(callCount === 1 ? { done: false, value: {} } : { done: true });
-        }),
-        [Symbol.asyncIterator]: function () {
-          return this;
-        },
-      };
-
-      const mockSession = {
-        supportsInject: vi.fn().mockReturnValue(true),
-        inject: vi.fn().mockResolvedValue({ success: false }),
-        interruptWith: vi.fn().mockReturnValue(mockIterator),
-      };
-
-      mockDeps.agentManager.getSession = vi.fn().mockReturnValue(mockSession);
-      mockDeps.systemEventQueue.getAgentsWithEvents = vi
-        .fn()
-        .mockReturnValue(["agent_1" as AgentId]);
-      mockDeps.systemEventQueue.drainText = vi.fn().mockReturnValue(["Event 1"]);
-
-      wakeManager.start();
-      const result = await wakeManager.runWakeCycle({ reason: "test" });
-
-      expect(result.status).toBe("ran");
-      expect(mockSession.interruptWith).toHaveBeenCalled();
-    });
-
-    it("should fall back to prompt if no session", async () => {
-      mockDeps.agentManager.getSession = vi.fn().mockReturnValue(null);
-      mockDeps.agentManager.get = vi.fn().mockReturnValue({ state: "running" });
-
-      const mockPromptIterator = {
-        next: vi.fn().mockResolvedValue({ done: true }),
-        [Symbol.asyncIterator]: function () {
-          return this;
-        },
-      };
-      mockDeps.agentManager.prompt = vi.fn().mockReturnValue(mockPromptIterator);
-
-      mockDeps.systemEventQueue.getAgentsWithEvents = vi
-        .fn()
-        .mockReturnValue(["agent_1" as AgentId]);
-      mockDeps.systemEventQueue.drainText = vi.fn().mockReturnValue(["Event 1"]);
-
-      wakeManager.start();
-      const result = await wakeManager.runWakeCycle({ reason: "test" });
-
-      expect(result.status).toBe("ran");
-      expect(mockDeps.agentManager.prompt).toHaveBeenCalled();
-    });
-
-    it("should re-queue events if delivery fails", async () => {
-      mockDeps.agentManager.getSession = vi.fn().mockReturnValue(null);
-      mockDeps.agentManager.get = vi.fn().mockReturnValue({ state: "stopped" });
-
-      mockDeps.systemEventQueue.getAgentsWithEvents = vi
-        .fn()
-        .mockReturnValue(["agent_1" as AgentId]);
-      mockDeps.systemEventQueue.drainText = vi.fn().mockReturnValue(["Event 1"]);
-
-      wakeManager.start();
-      const result = await wakeManager.runWakeCycle({ reason: "test" });
-
-      // Should have re-queued the event
-      expect(mockDeps.systemEventQueue.enqueue).toHaveBeenCalledWith("Event 1", {
-        agentId: "agent_1",
-      });
-      expect(result.status).toBe("failed");
-    });
-
-    it("should process multiple agents", async () => {
-      const mockSession = {
-        supportsInject: vi.fn().mockReturnValue(true),
-        inject: vi.fn().mockResolvedValue({ success: true }),
-      };
-
-      mockDeps.agentManager.getSession = vi.fn().mockReturnValue(mockSession);
-      mockDeps.systemEventQueue.getAgentsWithEvents = vi
-        .fn()
-        .mockReturnValue(["agent_1" as AgentId, "agent_2" as AgentId]);
-      mockDeps.systemEventQueue.drainText = vi.fn().mockReturnValue(["Event"]);
-
-      wakeManager.start();
-      const result = await wakeManager.runWakeCycle({ reason: "test" });
-
-      expect(result.status).toBe("ran");
-      expect(result.wokenAgents).toHaveLength(2);
-      expect(result.wokenAgents).toContain("agent_1");
-      expect(result.wokenAgents).toContain("agent_2");
-    });
-
-    it("should handle empty queue gracefully", async () => {
-      mockDeps.systemEventQueue.getAgentsWithEvents = vi.fn().mockReturnValue([]);
-
-      wakeManager.start();
-      const result = await wakeManager.runWakeCycle({ reason: "test" });
-
-      expect(result.status).toBe("ran");
-      expect(result.wokenAgents).toHaveLength(0);
-    });
-  });
-
-  describe("heartbeat", () => {
-    it("should not run heartbeat by default", async () => {
-      mockDeps.systemEventQueue.getAgentsWithEvents = vi
-        .fn()
-        .mockReturnValue(["agent_1" as AgentId]);
-
-      wakeManager.start();
-
-      // Advance past default heartbeat interval (30s)
-      await vi.advanceTimersByTimeAsync(35000);
-
-      // No wake should have been triggered since heartbeat is disabled by default
-      expect(wakeManager.hasPendingWake()).toBe(false);
-    });
-
-    it("should trigger wake on heartbeat when enabled", async () => {
-      wakeManager = createWakeManager(mockDeps, {
-        enableHeartbeat: true,
-        heartbeatIntervalMs: 1000,
-      });
-
-      mockDeps.systemEventQueue.getAgentsWithEvents = vi
-        .fn()
-        .mockReturnValue(["agent_1" as AgentId]);
-      mockDeps.systemEventQueue.drainText = vi.fn().mockReturnValue(["Event"]);
-
-      const mockSession = {
-        supportsInject: vi.fn().mockReturnValue(true),
-        inject: vi.fn().mockResolvedValue({ success: true }),
-      };
-      mockDeps.agentManager.getSession = vi.fn().mockReturnValue(mockSession);
-
-      wakeManager.start();
-
-      // Advance past heartbeat interval
-      await vi.advanceTimersByTimeAsync(1100);
-
-      expect(wakeManager.hasPendingWake()).toBe(true);
-    });
-
-    it("should stop heartbeat on stop", () => {
-      wakeManager = createWakeManager(mockDeps, {
-        enableHeartbeat: true,
-        heartbeatIntervalMs: 1000,
-      });
-
-      wakeManager.start();
-      wakeManager.stop();
-
-      // Heartbeat should be stopped
-      expect(wakeManager.isRunning()).toBe(false);
-    });
-  });
-
-  describe("pending reason tracking", () => {
-    it("should track pending reason", () => {
-      wakeManager.start();
-
-      expect(wakeManager.getPendingReason()).toBeNull();
-
-      wakeManager.requestWakeNow({ reason: "trigger:cron" });
-      expect(wakeManager.getPendingReason()).toBe("trigger:cron");
-    });
-
-    it("should clear pending reason after cycle", async () => {
-      mockDeps.systemEventQueue.getAgentsWithEvents = vi.fn().mockReturnValue([]);
-
-      wakeManager.start();
-      wakeManager.requestWakeNow({ reason: "test" });
-
-      // Run the scheduled wake
-      await vi.advanceTimersByTimeAsync(300);
-
-      expect(wakeManager.getPendingReason()).toBeNull();
-    });
-  });
-});
-
-// =============================================================================
-// Test Helpers
-// =============================================================================
-
-function createMockDeps() {
-  return {
-    agentManager: {
-      list: vi.fn().mockReturnValue([]),
-      get: vi.fn().mockReturnValue(null),
-      getSession: vi.fn().mockReturnValue(null),
-      prompt: vi.fn().mockReturnValue({
-        [Symbol.asyncIterator]: () => ({
-          next: vi.fn().mockResolvedValue({ done: true }),
-        }),
-      }),
-    } as any,
-    systemEventQueue: {
-      enqueue: vi.fn(),
-      drainText: vi.fn().mockReturnValue([]),
-      getAgentsWithEvents: vi.fn().mockReturnValue([]),
-      getEventCount: vi.fn().mockReturnValue(0),
-    } as any,
-  };
-}