@herdctl/core 0.0.1 → 0.0.2

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

@@ -1,601 +0,0 @@
-/**
- * Tests for manual agent triggering (US-5)
- *
- * Tests the trigger() method for manually triggering agents.
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { mkdtemp, rm, mkdir, writeFile } from "fs/promises";
-import { tmpdir } from "os";
-import { join } from "path";
-import { FleetManager } from "../fleet-manager.js";
-import {
-  AgentNotFoundError,
-  ScheduleNotFoundError,
-  ConcurrencyLimitError,
-  InvalidStateError,
-} from "../errors.js";
-import type { TriggerOptions, TriggerResult } from "../types.js";
-
-describe("Manual Agent Triggering (US-5)", () => {
-  let tempDir: string;
-  let configDir: string;
-  let stateDir: string;
-
-  beforeEach(async () => {
-    // Create temp directory for test
-    tempDir = await mkdtemp(join(tmpdir(), "fleet-trigger-test-"));
-    configDir = join(tempDir, "config");
-    stateDir = join(tempDir, ".herdctl");
-    await mkdir(configDir, { recursive: true });
-  });
-
-  afterEach(async () => {
-    // Cleanup
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  // Helper to create a test config file
-  async function createConfig(config: object) {
-    const configPath = join(configDir, "herdctl.yaml");
-    const yaml = await import("yaml");
-    await writeFile(configPath, yaml.stringify(config));
-    return configPath;
-  }
-
-  // Helper to create an agent config file
-  async function createAgentConfig(name: string, config: object) {
-    const agentDir = join(configDir, "agents");
-    await mkdir(agentDir, { recursive: true });
-    const agentPath = join(agentDir, `${name}.yaml`);
-    const yaml = await import("yaml");
-    await writeFile(agentPath, yaml.stringify(config));
-    return agentPath;
-  }
-
-  // Create a test manager with silent logger
-  function createTestManager(configPath: string) {
-    return new FleetManager({
-      configPath,
-      stateDir,
-      logger: {
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-      },
-    });
-  }
-
-  describe("trigger(agentName)", () => {
-    it("triggers an agent with defaults and returns job info", async () => {
-      await createAgentConfig("test-agent", {
-        name: "test-agent",
-        description: "Test agent for triggering",
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/test-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      const result = await manager.trigger("test-agent");
-
-      expect(result).toMatchObject({
-        agentName: "test-agent",
-        scheduleName: null,
-      });
-      expect(result.jobId).toMatch(/^job-\d{4}-\d{2}-\d{2}-[a-z0-9]{6}$/);
-      expect(result.startedAt).toBeDefined();
-    });
-
-    it("emits job:created event when triggering", async () => {
-      await createAgentConfig("event-agent", {
-        name: "event-agent",
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/event-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      const jobCreatedHandler = vi.fn();
-      manager.on("job:created", jobCreatedHandler);
-
-      const result = await manager.trigger("event-agent");
-
-      expect(jobCreatedHandler).toHaveBeenCalledTimes(1);
-      expect(jobCreatedHandler).toHaveBeenCalledWith(
-        expect.objectContaining({
-          job: expect.objectContaining({
-            id: result.jobId,
-            agent: "event-agent",
-            trigger_type: "manual",
-          }),
-          agentName: "event-agent",
-          scheduleName: null,
-        })
-      );
-    });
-
-    it("throws InvalidStateError before initialization", async () => {
-      const configPath = await createConfig({
-        version: 1,
-        agents: [],
-      });
-
-      const manager = createTestManager(configPath);
-
-      await expect(manager.trigger("any-agent")).rejects.toThrow(
-        InvalidStateError
-      );
-      await expect(manager.trigger("any-agent")).rejects.toMatchObject({
-        operation: "trigger",
-        currentState: "uninitialized",
-      });
-    });
-
-    it("throws AgentNotFoundError for unknown agent", async () => {
-      await createAgentConfig("known-agent", {
-        name: "known-agent",
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/known-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      await expect(manager.trigger("unknown-agent")).rejects.toThrow(
-        AgentNotFoundError
-      );
-      await expect(manager.trigger("unknown-agent")).rejects.toMatchObject({
-        agentName: "unknown-agent",
-        availableAgents: ["known-agent"],
-      });
-    });
-  });
-
-  describe("trigger(agentName, scheduleName)", () => {
-    it("triggers with a specific schedule", async () => {
-      await createAgentConfig("scheduled-agent", {
-        name: "scheduled-agent",
-        schedules: {
-          hourly: {
-            type: "interval",
-            interval: "1h",
-            prompt: "Check hourly tasks",
-          },
-          daily: {
-            type: "interval",
-            interval: "24h",
-            prompt: "Check daily tasks",
-          },
-        },
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/scheduled-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      const result = await manager.trigger("scheduled-agent", "hourly");
-
-      expect(result).toMatchObject({
-        agentName: "scheduled-agent",
-        scheduleName: "hourly",
-        prompt: "Check hourly tasks",
-      });
-    });
-
-    it("uses schedule prompt if no override provided", async () => {
-      await createAgentConfig("prompt-agent", {
-        name: "prompt-agent",
-        schedules: {
-          review: {
-            type: "interval",
-            interval: "1h",
-            prompt: "Review code changes",
-          },
-        },
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/prompt-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      const result = await manager.trigger("prompt-agent", "review");
-
-      expect(result.prompt).toBe("Review code changes");
-    });
-
-    it("throws ScheduleNotFoundError for unknown schedule", async () => {
-      await createAgentConfig("schedule-test", {
-        name: "schedule-test",
-        schedules: {
-          known: { type: "interval", interval: "1h" },
-        },
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/schedule-test.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      await expect(
-        manager.trigger("schedule-test", "unknown")
-      ).rejects.toThrow(ScheduleNotFoundError);
-      await expect(
-        manager.trigger("schedule-test", "unknown")
-      ).rejects.toMatchObject({
-        agentName: "schedule-test",
-        scheduleName: "unknown",
-        availableSchedules: ["known"],
-      });
-    });
-
-    it("throws ScheduleNotFoundError for agent without schedules", async () => {
-      await createAgentConfig("no-schedules", {
-        name: "no-schedules",
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/no-schedules.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      await expect(
-        manager.trigger("no-schedules", "any-schedule")
-      ).rejects.toThrow(ScheduleNotFoundError);
-      await expect(
-        manager.trigger("no-schedules", "any-schedule")
-      ).rejects.toMatchObject({
-        availableSchedules: [],
-      });
-    });
-  });
-
-  describe("trigger(agentName, scheduleName?, options)", () => {
-    it("allows prompt override via options", async () => {
-      await createAgentConfig("override-agent", {
-        name: "override-agent",
-        schedules: {
-          default: {
-            type: "interval",
-            interval: "1h",
-            prompt: "Default prompt",
-          },
-        },
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/override-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      const result = await manager.trigger("override-agent", "default", {
-        prompt: "Custom prompt",
-      });
-
-      expect(result.prompt).toBe("Custom prompt");
-    });
-
-    it("uses option prompt when no schedule specified", async () => {
-      await createAgentConfig("no-schedule-prompt", {
-        name: "no-schedule-prompt",
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/no-schedule-prompt.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      const result = await manager.trigger("no-schedule-prompt", undefined, {
-        prompt: "Override prompt",
-      });
-
-      expect(result.prompt).toBe("Override prompt");
-    });
-
-    it("prompt priority: options > schedule > undefined", async () => {
-      await createAgentConfig("priority-agent", {
-        name: "priority-agent",
-        schedules: {
-          with_prompt: {
-            type: "interval",
-            interval: "1h",
-            prompt: "Schedule prompt",
-          },
-          no_prompt: {
-            type: "interval",
-            interval: "1h",
-          },
-        },
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/priority-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      // Option overrides schedule
-      const r1 = await manager.trigger("priority-agent", "with_prompt", {
-        prompt: "Option prompt",
-      });
-      expect(r1.prompt).toBe("Option prompt");
-
-      // Schedule used when no option
-      const r2 = await manager.trigger("priority-agent", "with_prompt");
-      expect(r2.prompt).toBe("Schedule prompt");
-
-      // No prompt when neither specified
-      const r3 = await manager.trigger("priority-agent", "no_prompt");
-      expect(r3.prompt).toBeUndefined();
-    });
-  });
-
-  describe("concurrency limits", () => {
-    it("respects max_concurrent by default", async () => {
-      await createAgentConfig("limited-agent", {
-        name: "limited-agent",
-        instances: { max_concurrent: 1 },
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/limited-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      // First trigger should succeed
-      const result1 = await manager.trigger("limited-agent");
-      expect(result1.jobId).toBeDefined();
-
-      // Note: In a real scenario, the job would be running and the second trigger
-      // would fail. Here we're just testing the concurrency check logic.
-      // The scheduler tracks running jobs, but since we're not using the scheduler
-      // to run jobs in this test, subsequent triggers will succeed.
-    });
-
-    it("allows bypass with bypassConcurrencyLimit option", async () => {
-      await createAgentConfig("bypass-agent", {
-        name: "bypass-agent",
-        instances: { max_concurrent: 1 },
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/bypass-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      // Trigger with bypass should succeed
-      const result = await manager.trigger("bypass-agent", undefined, {
-        bypassConcurrencyLimit: true,
-      });
-      expect(result.jobId).toBeDefined();
-    });
-
-    it("defaults max_concurrent to 1 if not specified", async () => {
-      await createAgentConfig("default-max", {
-        name: "default-max",
-        // No instances config
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/default-max.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      // Should work - default max_concurrent is 1
-      const result = await manager.trigger("default-max");
-      expect(result.jobId).toBeDefined();
-    });
-  });
-
-  describe("trigger works in different states", () => {
-    it("works after initialization", async () => {
-      await createAgentConfig("init-agent", {
-        name: "init-agent",
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/init-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      const result = await manager.trigger("init-agent");
-      expect(result.agentName).toBe("init-agent");
-    });
-
-    it("works while running", async () => {
-      await createAgentConfig("running-agent", {
-        name: "running-agent",
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/running-agent.yaml" }],
-      });
-
-      const manager = new FleetManager({
-        configPath,
-        stateDir,
-        checkInterval: 10000, // Long interval
-        logger: {
-          debug: vi.fn(),
-          info: vi.fn(),
-          warn: vi.fn(),
-          error: vi.fn(),
-        },
-      });
-
-      await manager.initialize();
-      await manager.start();
-
-      const result = await manager.trigger("running-agent");
-      expect(result.agentName).toBe("running-agent");
-
-      await manager.stop();
-    });
-
-    it("works after stopping", async () => {
-      await createAgentConfig("stopped-agent", {
-        name: "stopped-agent",
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/stopped-agent.yaml" }],
-      });
-
-      const manager = new FleetManager({
-        configPath,
-        stateDir,
-        checkInterval: 10000,
-        logger: {
-          debug: vi.fn(),
-          info: vi.fn(),
-          warn: vi.fn(),
-          error: vi.fn(),
-        },
-      });
-
-      await manager.initialize();
-      await manager.start();
-      await manager.stop();
-
-      const result = await manager.trigger("stopped-agent");
-      expect(result.agentName).toBe("stopped-agent");
-    });
-  });
-
-  describe("job creation", () => {
-    it("creates job with correct trigger_type", async () => {
-      await createAgentConfig("trigger-type-agent", {
-        name: "trigger-type-agent",
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/trigger-type-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      const jobCreatedHandler = vi.fn();
-      manager.on("job:created", jobCreatedHandler);
-
-      await manager.trigger("trigger-type-agent");
-
-      expect(jobCreatedHandler).toHaveBeenCalledWith(
-        expect.objectContaining({
-          job: expect.objectContaining({
-            trigger_type: "manual",
-          }),
-        })
-      );
-    });
-
-    it("stores schedule name in job when provided", async () => {
-      await createAgentConfig("job-schedule-agent", {
-        name: "job-schedule-agent",
-        schedules: {
-          test: { type: "interval", interval: "1h" },
-        },
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/job-schedule-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      const jobCreatedHandler = vi.fn();
-      manager.on("job:created", jobCreatedHandler);
-
-      await manager.trigger("job-schedule-agent", "test");
-
-      expect(jobCreatedHandler).toHaveBeenCalledWith(
-        expect.objectContaining({
-          scheduleName: "test",
-          job: expect.objectContaining({
-            schedule: "test",
-          }),
-        })
-      );
-    });
-
-    it("stores prompt in job metadata", async () => {
-      await createAgentConfig("job-prompt-agent", {
-        name: "job-prompt-agent",
-      });
-
-      const configPath = await createConfig({
-        version: 1,
-        agents: [{ path: "./agents/job-prompt-agent.yaml" }],
-      });
-
-      const manager = createTestManager(configPath);
-      await manager.initialize();
-
-      const jobCreatedHandler = vi.fn();
-      manager.on("job:created", jobCreatedHandler);
-
-      await manager.trigger("job-prompt-agent", undefined, {
-        prompt: "Test prompt for job",
-      });
-
-      expect(jobCreatedHandler).toHaveBeenCalledWith(
-        expect.objectContaining({
-          job: expect.objectContaining({
-            prompt: "Test prompt for job",
-          }),
-        })
-      );
-    });
-  });
-});