npm - @useatlas/create - Versions diffs - 0.0.6 → 0.0.7 - Mend

@useatlas/create 0.0.6 → 0.0.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (952) hide show

package/templates/docker/src/lib/scheduler/__tests__/delivery.test.ts DELETED Viewed

@@ -1,192 +0,0 @@
-/**
- * Unit tests for the delivery dispatcher.
- */
-import { describe, it, expect, beforeEach, afterEach, mock } from "bun:test";
-import type { ScheduledTask } from "@atlas/api/lib/scheduled-tasks";
-import type { AgentQueryResult } from "@atlas/api/lib/agent-query";
-// Mock formatters
-mock.module("../format-email", () => ({
-  formatEmailReport: mock(() => ({ subject: "Subject", body: "<html>body</html>" })),
-}));
-mock.module("../format-slack", () => ({
-  formatSlackReport: mock(() => ({ text: "Report", blocks: [] })),
-}));
-mock.module("../format-webhook", () => ({
-  formatWebhookPayload: mock(() => ({ taskId: "t", answer: "A" })),
-}));
-// Mock fetch for delivery
-const originalFetch = globalThis.fetch;
-const mockFetch = mock(() => Promise.resolve(new Response("ok", { status: 200 })));
-const { deliverResult } = await import("../delivery");
-function makeTask(overrides: Partial<ScheduledTask> = {}): ScheduledTask {
-  return {
-    id: "task-123",
-    ownerId: "u1",
-    name: "Test Report",
-    question: "Q?",
-    cronExpression: "0 9 * * 1",
-    deliveryChannel: "webhook",
-    recipients: [],
-    connectionId: null,
-    approvalMode: "auto",
-    enabled: true,
-    lastRunAt: null,
-    nextRunAt: null,
-    createdAt: "2024-01-01T00:00:00Z",
-    updatedAt: "2024-01-01T00:00:00Z",
-    ...overrides,
-  };
-}
-function makeResult(): AgentQueryResult {
-  return {
-    answer: "Revenue was $1M",
-    sql: ["SELECT SUM(revenue) FROM orders"],
-    data: [{ columns: ["total"], rows: [{ total: 1000000 }] }],
-    steps: 3,
-    usage: { totalTokens: 1500 },
-  };
-}
-describe("delivery dispatcher", () => {
-  beforeEach(() => {
-    mockFetch.mockReset();
-    mockFetch.mockResolvedValue(new Response("ok", { status: 200 }));
-    globalThis.fetch = mockFetch as unknown as typeof fetch;
-  });
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-  it("returns zero summary when no recipients", async () => {
-    const task = makeTask({ recipients: [] });
-    const summary = await deliverResult(task, makeResult());
-    expect(summary).toEqual({ attempted: 0, succeeded: 0, failed: 0 });
-    expect(mockFetch).not.toHaveBeenCalled();
-  });
-  it("delivers webhook and returns success summary", async () => {
-    const task = makeTask({
-      deliveryChannel: "webhook",
-      recipients: [{ type: "webhook", url: "https://hook.example.com" }],
-    });
-    const summary = await deliverResult(task, makeResult());
-    expect(summary).toEqual({ attempted: 1, succeeded: 1, failed: 0 });
-    expect(mockFetch).toHaveBeenCalledTimes(1);
-    const callArgs = mockFetch.mock.calls[0] as unknown as [string, RequestInit];
-    expect(callArgs[0]).toBe("https://hook.example.com");
-  });
-  it("delivers email via Resend when API key is set", async () => {
-    const origKey = process.env.RESEND_API_KEY;
-    process.env.RESEND_API_KEY = "re_test_123";
-    const task = makeTask({
-      deliveryChannel: "email",
-      recipients: [{ type: "email", address: "test@example.com" }],
-    });
-    const summary = await deliverResult(task, makeResult());
-    expect(summary.succeeded).toBe(1);
-    expect(mockFetch).toHaveBeenCalledTimes(1);
-    const callArgs = mockFetch.mock.calls[0] as unknown as [string, RequestInit];
-    expect(callArgs[0]).toBe("https://api.resend.com/emails");
-    if (origKey) process.env.RESEND_API_KEY = origKey;
-    else delete process.env.RESEND_API_KEY;
-  });
-  it("reports failure when no RESEND_API_KEY", async () => {
-    const origKey = process.env.RESEND_API_KEY;
-    delete process.env.RESEND_API_KEY;
-    const task = makeTask({
-      deliveryChannel: "email",
-      recipients: [{ type: "email", address: "test@example.com" }],
-    });
-    const summary = await deliverResult(task, makeResult());
-    expect(summary).toEqual({ attempted: 1, succeeded: 0, failed: 1 });
-    expect(mockFetch).not.toHaveBeenCalled();
-    if (origKey) process.env.RESEND_API_KEY = origKey;
-  });
-  it("reports failure on webhook delivery error", async () => {
-    mockFetch.mockResolvedValueOnce(new Response("error", { status: 500 }));
-    const task = makeTask({
-      deliveryChannel: "webhook",
-      recipients: [{ type: "webhook", url: "https://hook.example.com" }],
-    });
-    const summary = await deliverResult(task, makeResult());
-    expect(summary).toEqual({ attempted: 1, succeeded: 0, failed: 1 });
-  });
-  it("reports failure on fetch network error", async () => {
-    mockFetch.mockRejectedValueOnce(new Error("network error"));
-    const task = makeTask({
-      deliveryChannel: "webhook",
-      recipients: [{ type: "webhook", url: "https://hook.example.com" }],
-    });
-    const summary = await deliverResult(task, makeResult());
-    expect(summary).toEqual({ attempted: 1, succeeded: 0, failed: 1 });
-  });
-  it("includes safe custom headers for webhook recipients", async () => {
-    const task = makeTask({
-      deliveryChannel: "webhook",
-      recipients: [{ type: "webhook", url: "https://hook.example.com", headers: { "X-Key": "abc" } }],
-    });
-    await deliverResult(task, makeResult());
-    const callArgs = mockFetch.mock.calls[0] as unknown as [string, RequestInit];
-    const headers = callArgs[1].headers as Record<string, string>;
-    expect(headers["X-Key"]).toBe("abc");
-  });
-  it("blocks sensitive headers in webhook recipients", async () => {
-    const task = makeTask({
-      deliveryChannel: "webhook",
-      recipients: [{ type: "webhook", url: "https://hook.example.com", headers: { "Authorization": "Bearer secret", "X-Safe": "ok" } }],
-    });
-    await deliverResult(task, makeResult());
-    const callArgs = mockFetch.mock.calls[0] as unknown as [string, RequestInit];
-    const headers = callArgs[1].headers as Record<string, string>;
-    expect(headers["X-Safe"]).toBe("ok");
-    expect(headers["Authorization"]).toBeUndefined();
-  });
-  it("blocks webhook URLs targeting private/internal addresses", async () => {
-    const task = makeTask({
-      deliveryChannel: "webhook",
-      recipients: [{ type: "webhook", url: "http://169.254.169.254/latest/meta-data/" }],
-    });
-    const summary = await deliverResult(task, makeResult());
-    expect(summary).toEqual({ attempted: 1, succeeded: 0, failed: 1 });
-    expect(mockFetch).not.toHaveBeenCalled();
-  });
-  it("blocks webhook URLs targeting localhost", async () => {
-    const task = makeTask({
-      deliveryChannel: "webhook",
-      recipients: [{ type: "webhook", url: "http://localhost:3001/api/health" }],
-    });
-    const summary = await deliverResult(task, makeResult());
-    expect(summary.failed).toBe(1);
-    expect(mockFetch).not.toHaveBeenCalled();
-  });
-  it("blocks webhook URLs targeting private 10.x.x.x range", async () => {
-    const task = makeTask({
-      deliveryChannel: "webhook",
-      recipients: [{ type: "webhook", url: "http://10.0.0.1/internal" }],
-    });
-    const summary = await deliverResult(task, makeResult());
-    expect(summary.failed).toBe(1);
-    expect(mockFetch).not.toHaveBeenCalled();
-  });
-});

package/templates/docker/src/lib/scheduler/__tests__/engine.test.ts DELETED Viewed

@@ -1,248 +0,0 @@
-/**
- * Unit tests for the scheduler engine.
- */
-import { describe, it, expect, beforeEach, afterEach, mock } from "bun:test";
-// Mock dependencies before importing
-const mockGetTasksDueForExecution = mock((): Promise<unknown[]> => Promise.resolve([]));
-const mockLockTaskForExecution = mock((): Promise<boolean> => Promise.resolve(true));
-const mockCreateTaskRun = mock((): Promise<string | null> => Promise.resolve("run-123"));
-const mockCompleteTaskRun = mock((): void => {});
-const mockGetScheduledTask = mock((): Promise<unknown> =>
-  Promise.resolve({ ok: true, data: { id: "task-123", question: "Q?", cronExpression: "0 9 * * 1" } }),
-);
-const mockComputeNextRun = mock((): Date | null => new Date("2025-01-01T09:00:00Z"));
-mock.module("@atlas/api/lib/scheduled-tasks", () => ({
-  getTasksDueForExecution: mockGetTasksDueForExecution,
-  lockTaskForExecution: mockLockTaskForExecution,
-  createTaskRun: mockCreateTaskRun,
-  completeTaskRun: mockCompleteTaskRun,
-  getScheduledTask: mockGetScheduledTask,
-  computeNextRun: mockComputeNextRun,
-}));
-mock.module("@atlas/api/lib/db/internal", () => ({
-  internalExecute: mock(() => {}),
-}));
-const mockExecuteResult = {
-  tokensUsed: 1500,
-  deliveryAttempted: 1,
-  deliverySucceeded: 1,
-  deliveryFailed: 0,
-};
-const mockExecuteScheduledTask = mock(() => Promise.resolve(mockExecuteResult));
-mock.module("../executor", () => ({
-  executeScheduledTask: mockExecuteScheduledTask,
-}));
-mock.module("@atlas/api/lib/config", () => ({
-  getConfig: () => ({
-    scheduler: {
-      maxConcurrentTasks: 5,
-      taskTimeout: 60_000,
-      tickIntervalSeconds: 1,
-    },
-  }),
-}));
-const { getScheduler, triggerTask, runTick, _resetScheduler } = await import("../engine");
-describe("scheduler engine", () => {
-  beforeEach(() => {
-    _resetScheduler();
-    mockGetTasksDueForExecution.mockReset();
-    mockGetTasksDueForExecution.mockResolvedValue([]);
-    mockLockTaskForExecution.mockReset();
-    mockLockTaskForExecution.mockResolvedValue(true);
-    mockCreateTaskRun.mockReset();
-    mockCreateTaskRun.mockResolvedValue("run-123");
-    mockCompleteTaskRun.mockReset();
-    mockExecuteScheduledTask.mockReset();
-    mockExecuteScheduledTask.mockResolvedValue(mockExecuteResult);
-    mockGetScheduledTask.mockReset();
-    mockGetScheduledTask.mockResolvedValue({ ok: true, data: { id: "task-123", question: "Q?", cronExpression: "0 9 * * 1" } });
-    mockComputeNextRun.mockReset();
-    mockComputeNextRun.mockReturnValue(new Date("2025-01-01T09:00:00Z"));
-  });
-  afterEach(() => {
-    _resetScheduler();
-  });
-  describe("getScheduler()", () => {
-    it("returns a singleton", () => {
-      const s1 = getScheduler();
-      const s2 = getScheduler();
-      expect(s1).toBe(s2);
-    });
-    it("starts and stops", () => {
-      const scheduler = getScheduler();
-      expect(scheduler.isRunning()).toBe(false);
-      scheduler.start();
-      expect(scheduler.isRunning()).toBe(true);
-      scheduler.stop();
-      expect(scheduler.isRunning()).toBe(false);
-    });
-    it("start is idempotent", () => {
-      const scheduler = getScheduler();
-      scheduler.start();
-      scheduler.start(); // Should not throw
-      expect(scheduler.isRunning()).toBe(true);
-    });
-    it("stop is idempotent", () => {
-      const scheduler = getScheduler();
-      scheduler.stop(); // Not running — should not throw
-      expect(scheduler.isRunning()).toBe(false);
-    });
-  });
-  describe("triggerTask()", () => {
-    it("executes a task immediately and records token usage", async () => {
-      await triggerTask("task-123");
-      expect(mockLockTaskForExecution).toHaveBeenCalledWith("task-123");
-      expect(mockCreateTaskRun).toHaveBeenCalledWith("task-123");
-      expect(mockExecuteScheduledTask).toHaveBeenCalledWith("task-123", "run-123", 60_000);
-      expect(mockCompleteTaskRun).toHaveBeenCalledWith("run-123", "success", { tokensUsed: 1500 });
-    });
-    it("throws when lock fails", async () => {
-      mockLockTaskForExecution.mockResolvedValueOnce(false);
-      await expect(triggerTask("task-123")).rejects.toThrow("Failed to lock task");
-    });
-    it("throws when createTaskRun fails", async () => {
-      mockCreateTaskRun.mockResolvedValueOnce(null);
-      await expect(triggerTask("task-123")).rejects.toThrow("Failed to create run record");
-    });
-    it("marks run as failed on execution error", async () => {
-      mockExecuteScheduledTask.mockRejectedValueOnce(new Error("boom"));
-      await expect(triggerTask("task-123")).rejects.toThrow("boom");
-      expect(mockCompleteTaskRun).toHaveBeenCalledWith("run-123", "failed", { error: "boom" });
-    });
-  });
-  describe("runTick()", () => {
-    it("returns zero counts when no tasks are due", async () => {
-      mockGetTasksDueForExecution.mockResolvedValueOnce([]);
-      const result = await runTick();
-      expect(result).toEqual({
-        tasksFound: 0,
-        tasksDispatched: 0,
-        tasksCompleted: 0,
-        tasksFailed: 0,
-      });
-      expect(result.error).toBeUndefined();
-    });
-    it("awaits completion and returns correct counts", async () => {
-      mockGetTasksDueForExecution.mockResolvedValueOnce([
-        { id: "t1" },
-        { id: "t2" },
-      ]);
-      const result = await runTick();
-      expect(result).toEqual({
-        tasksFound: 2,
-        tasksDispatched: 2,
-        tasksCompleted: 2,
-        tasksFailed: 0,
-      });
-      expect(mockExecuteScheduledTask).toHaveBeenCalledTimes(2);
-    });
-    it("counts execution failures in tasksFailed", async () => {
-      mockGetTasksDueForExecution.mockResolvedValueOnce([{ id: "t1" }]);
-      mockExecuteScheduledTask.mockRejectedValueOnce(new Error("boom"));
-      const result = await runTick();
-      expect(result).toEqual({
-        tasksFound: 1,
-        tasksDispatched: 1,
-        tasksCompleted: 0,
-        tasksFailed: 1,
-      });
-      expect(mockCompleteTaskRun).toHaveBeenCalledWith("run-123", "failed", { error: "boom" });
-    });
-    it("skips tasks that fail to lock (not counted as failure)", async () => {
-      mockGetTasksDueForExecution.mockResolvedValueOnce([{ id: "t1" }, { id: "t2" }]);
-      mockLockTaskForExecution
-        .mockResolvedValueOnce(false) // t1 — lock fails
-        .mockResolvedValueOnce(true); // t2 — lock succeeds
-      const result = await runTick();
-      expect(result).toEqual({
-        tasksFound: 2,
-        tasksDispatched: 1,
-        tasksCompleted: 1,
-        tasksFailed: 0,
-      });
-    });
-    it("respects maxConcurrentTasks limit", async () => {
-      // Config mock returns maxConcurrentTasks: 5, but we send 7 tasks
-      mockGetTasksDueForExecution.mockResolvedValueOnce([
-        { id: "t1" }, { id: "t2" }, { id: "t3" },
-        { id: "t4" }, { id: "t5" }, { id: "t6" }, { id: "t7" },
-      ]);
-      const result = await runTick();
-      expect(result.tasksFound).toBe(7);
-      expect(result.tasksDispatched).toBe(5); // capped at maxConcurrentTasks
-      expect(mockExecuteScheduledTask).toHaveBeenCalledTimes(5);
-      expect(mockLockTaskForExecution).toHaveBeenCalledTimes(5);
-    });
-    it("surfaces error when getTasksDueForExecution throws", async () => {
-      mockGetTasksDueForExecution.mockRejectedValueOnce(new Error("db down"));
-      const result = await runTick();
-      expect(result.error).toBe("db down");
-      expect(result.tasksFound).toBe(0);
-      expect(result.tasksDispatched).toBe(0);
-    });
-    it("counts createTaskRun failure as tasksFailed without executing", async () => {
-      mockGetTasksDueForExecution.mockResolvedValueOnce([{ id: "t1" }]);
-      mockCreateTaskRun.mockResolvedValueOnce(null);
-      const result = await runTick();
-      expect(result).toEqual({
-        tasksFound: 1,
-        tasksDispatched: 1,
-        tasksCompleted: 0,
-        tasksFailed: 1,
-      });
-      expect(mockExecuteScheduledTask).not.toHaveBeenCalled();
-      expect(mockCompleteTaskRun).not.toHaveBeenCalled();
-      // Should attempt to reschedule
-      expect(mockGetScheduledTask).toHaveBeenCalledWith("t1");
-    });
-    it("skips tasks where lockTaskForExecution throws", async () => {
-      mockGetTasksDueForExecution.mockResolvedValueOnce([{ id: "t1" }, { id: "t2" }]);
-      mockLockTaskForExecution
-        .mockRejectedValueOnce(new Error("lock query timeout"))
-        .mockResolvedValueOnce(true);
-      const result = await runTick();
-      expect(result).toEqual({
-        tasksFound: 2,
-        tasksDispatched: 1,
-        tasksCompleted: 1,
-        tasksFailed: 0,
-      });
-    });
-  });
-  describe("_resetScheduler()", () => {
-    it("stops and clears the singleton", () => {
-      const s1 = getScheduler();
-      s1.start();
-      _resetScheduler();
-      const s2 = getScheduler();
-      expect(s2).not.toBe(s1);
-      expect(s2.isRunning()).toBe(false);
-    });
-  });
-});

package/templates/docker/src/lib/scheduler/__tests__/format-email.test.ts DELETED Viewed

@@ -1,96 +0,0 @@
-/**
- * Unit tests for the email formatter.
- */
-import { describe, it, expect } from "bun:test";
-import { formatEmailReport } from "../format-email";
-import type { ScheduledTask } from "@atlas/api/lib/scheduled-tasks";
-import type { AgentQueryResult } from "@atlas/api/lib/agent-query";
-function makeTask(overrides: Partial<ScheduledTask> = {}): ScheduledTask {
-  return {
-    id: "task-123",
-    ownerId: "u1",
-    name: "Daily Revenue",
-    question: "What was yesterday's revenue?",
-    cronExpression: "0 9 * * 1",
-    deliveryChannel: "email",
-    recipients: [],
-    connectionId: null,
-    approvalMode: "auto",
-    enabled: true,
-    lastRunAt: null,
-    nextRunAt: null,
-    createdAt: "2024-01-01T00:00:00Z",
-    updatedAt: "2024-01-01T00:00:00Z",
-    ...overrides,
-  };
-}
-function makeResult(overrides: Partial<AgentQueryResult> = {}): AgentQueryResult {
-  return {
-    answer: "Revenue was $1M",
-    sql: ["SELECT SUM(revenue) FROM orders"],
-    data: [{ columns: ["total"], rows: [{ total: 1000000 }] }],
-    steps: 3,
-    usage: { totalTokens: 1500 },
-    ...overrides,
-  };
-}
-describe("formatEmailReport", () => {
-  it("produces subject and body", () => {
-    const { subject, body } = formatEmailReport(makeTask(), makeResult());
-    expect(subject).toBe("Atlas Report: Daily Revenue");
-    expect(body).toContain("Daily Revenue");
-    expect(body).toContain("Revenue was $1M");
-  });
-  it("includes data table", () => {
-    const { body } = formatEmailReport(makeTask(), makeResult());
-    expect(body).toContain("<table");
-    expect(body).toContain("total");
-    expect(body).toContain("1000000");
-  });
-  it("includes SQL", () => {
-    const { body } = formatEmailReport(makeTask(), makeResult());
-    expect(body).toContain("SELECT SUM(revenue)");
-  });
-  it("includes metadata footer", () => {
-    const { body } = formatEmailReport(makeTask(), makeResult());
-    expect(body).toContain("3 steps");
-    expect(body).toContain("1,500 tokens");
-  });
-  it("handles empty answer", () => {
-    const { body } = formatEmailReport(makeTask(), makeResult({ answer: "" }));
-    expect(body).toContain("No answer generated.");
-  });
-  it("handles empty data", () => {
-    const { body } = formatEmailReport(makeTask(), makeResult({ data: [] }));
-    expect(body).not.toContain("<table");
-  });
-  it("handles empty SQL", () => {
-    const { body } = formatEmailReport(makeTask(), makeResult({ sql: [] }));
-    expect(body).not.toContain("<pre");
-  });
-  it("escapes HTML in task name", () => {
-    const task = makeTask({ name: "Test <script>alert(1)</script>" });
-    const { body } = formatEmailReport(task, makeResult());
-    expect(body).not.toContain("<script>");
-    expect(body).toContain("&lt;script&gt;");
-  });
-  it("truncates large data tables", () => {
-    const rows = Array.from({ length: 100 }, (_, i) => ({ id: i, value: `row-${i}` }));
-    const { body } = formatEmailReport(
-      makeTask(),
-      makeResult({ data: [{ columns: ["id", "value"], rows }] }),
-    );
-    expect(body).toContain("Showing first 50");
-  });
-});

package/templates/docker/src/lib/scheduler/__tests__/format-slack.test.ts DELETED Viewed

@@ -1,78 +0,0 @@
-/**
- * Unit tests for the Slack formatter.
- */
-import { describe, it, expect } from "bun:test";
-import { formatSlackReport } from "../format-slack";
-import type { ScheduledTask } from "@atlas/api/lib/scheduled-tasks";
-import type { AgentQueryResult } from "@atlas/api/lib/agent-query";
-function makeTask(overrides: Partial<ScheduledTask> = {}): ScheduledTask {
-  return {
-    id: "task-123",
-    ownerId: "u1",
-    name: "Daily Revenue",
-    question: "What was yesterday's revenue?",
-    cronExpression: "0 9 * * 1",
-    deliveryChannel: "slack",
-    recipients: [],
-    connectionId: null,
-    approvalMode: "auto",
-    enabled: true,
-    lastRunAt: null,
-    nextRunAt: null,
-    createdAt: "2024-01-01T00:00:00Z",
-    updatedAt: "2024-01-01T00:00:00Z",
-    ...overrides,
-  };
-}
-function makeResult(overrides: Partial<AgentQueryResult> = {}): AgentQueryResult {
-  return {
-    answer: "Revenue was $1M",
-    sql: ["SELECT SUM(revenue) FROM orders"],
-    data: [{ columns: ["total"], rows: [{ total: 1000000 }] }],
-    steps: 3,
-    usage: { totalTokens: 1500 },
-    ...overrides,
-  };
-}
-describe("formatSlackReport", () => {
-  it("produces text and blocks", () => {
-    const { text, blocks } = formatSlackReport(makeTask(), makeResult());
-    expect(text).toContain("Daily Revenue");
-    expect(blocks.length).toBeGreaterThan(1);
-  });
-  it("includes header block with task name", () => {
-    const { blocks } = formatSlackReport(makeTask(), makeResult());
-    const header = blocks[0];
-    expect(header.type).toBe("section");
-    if ("text" in header) {
-      expect(header.text.text).toContain("*Daily Revenue*");
-    }
-  });
-  it("includes answer from formatQueryResponse", () => {
-    const { blocks } = formatSlackReport(makeTask(), makeResult());
-    const answerBlock = blocks.find(
-      (b) => b.type === "section" && "text" in b && b.text.text.includes("Revenue was $1M"),
-    );
-    expect(answerBlock).toBeDefined();
-  });
-  it("includes question in header", () => {
-    const { blocks } = formatSlackReport(makeTask(), makeResult());
-    if ("text" in blocks[0]) {
-      expect(blocks[0].text.text).toContain("yesterday's revenue");
-    }
-  });
-  it("truncates long questions", () => {
-    const longQuestion = "a".repeat(300);
-    const { blocks } = formatSlackReport(makeTask({ question: longQuestion }), makeResult());
-    if ("text" in blocks[0]) {
-      expect(blocks[0].text.text.length).toBeLessThan(350);
-    }
-  });
-});

package/templates/docker/src/lib/scheduler/__tests__/format-webhook.test.ts DELETED Viewed

@@ -1,78 +0,0 @@
-/**
- * Unit tests for the webhook formatter.
- */
-import { describe, it, expect } from "bun:test";
-import { formatWebhookPayload } from "../format-webhook";
-import type { ScheduledTask } from "@atlas/api/lib/scheduled-tasks";
-import type { AgentQueryResult } from "@atlas/api/lib/agent-query";
-function makeTask(overrides: Partial<ScheduledTask> = {}): ScheduledTask {
-  return {
-    id: "task-123",
-    ownerId: "u1",
-    name: "Daily Revenue",
-    question: "What was yesterday's revenue?",
-    cronExpression: "0 9 * * 1",
-    deliveryChannel: "webhook",
-    recipients: [],
-    connectionId: null,
-    approvalMode: "auto",
-    enabled: true,
-    lastRunAt: null,
-    nextRunAt: null,
-    createdAt: "2024-01-01T00:00:00Z",
-    updatedAt: "2024-01-01T00:00:00Z",
-    ...overrides,
-  };
-}
-function makeResult(overrides: Partial<AgentQueryResult> = {}): AgentQueryResult {
-  return {
-    answer: "Revenue was $1M",
-    sql: ["SELECT SUM(revenue) FROM orders"],
-    data: [{ columns: ["total"], rows: [{ total: 1000000 }] }],
-    steps: 3,
-    usage: { totalTokens: 1500 },
-    ...overrides,
-  };
-}
-describe("formatWebhookPayload", () => {
-  it("includes all required fields", () => {
-    const payload = formatWebhookPayload(makeTask(), makeResult());
-    expect(payload.taskId).toBe("task-123");
-    expect(payload.taskName).toBe("Daily Revenue");
-    expect(payload.question).toBe("What was yesterday's revenue?");
-    expect(payload.answer).toBe("Revenue was $1M");
-    expect(payload.sql).toEqual(["SELECT SUM(revenue) FROM orders"]);
-    expect(payload.data).toHaveLength(1);
-    expect(payload.steps).toBe(3);
-    expect(payload.usage.totalTokens).toBe(1500);
-    expect(payload.timestamp).toBeDefined();
-  });
-  it("includes ISO timestamp", () => {
-    const payload = formatWebhookPayload(makeTask(), makeResult());
-    expect(() => new Date(payload.timestamp)).not.toThrow();
-    expect(payload.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-  });
-  it("handles empty answer", () => {
-    const payload = formatWebhookPayload(makeTask(), makeResult({ answer: "" }));
-    expect(payload.answer).toBe("");
-  });
-  it("handles empty data", () => {
-    const payload = formatWebhookPayload(makeTask(), makeResult({ data: [] }));
-    expect(payload.data).toEqual([]);
-  });
-  it("preserves full data without truncation", () => {
-    const rows = Array.from({ length: 100 }, (_, i) => ({ id: i }));
-    const payload = formatWebhookPayload(
-      makeTask(),
-      makeResult({ data: [{ columns: ["id"], rows }] }),
-    );
-    expect(payload.data[0].rows.length).toBe(100);
-  });
-});